gllm-inference-binary 0.5.12__cp311-cp311-macosx_13_0_x86_64.whl → 0.5.14__cp311-cp311-macosx_13_0_x86_64.whl

gllm_inference/builder/build_lm_invoker.pyi

@@ -1,5 +1,5 @@
 from _typeshed import Incomplete
-from gllm_inference.lm_invoker import AnthropicLMInvoker as AnthropicLMInvoker, AzureOpenAILMInvoker as AzureOpenAILMInvoker, BedrockLMInvoker as BedrockLMInvoker, DatasaurLMInvoker as DatasaurLMInvoker, GoogleLMInvoker as GoogleLMInvoker, LangChainLMInvoker as LangChainLMInvoker, LiteLLMLMInvoker as LiteLLMLMInvoker, OpenAICompatibleLMInvoker as OpenAICompatibleLMInvoker, OpenAILMInvoker as OpenAILMInvoker
+from gllm_inference.lm_invoker import AnthropicLMInvoker as AnthropicLMInvoker, AzureOpenAILMInvoker as AzureOpenAILMInvoker, BedrockLMInvoker as BedrockLMInvoker, DatasaurLMInvoker as DatasaurLMInvoker, GoogleLMInvoker as GoogleLMInvoker, LangChainLMInvoker as LangChainLMInvoker, LiteLLMLMInvoker as LiteLLMLMInvoker, OpenAICompatibleLMInvoker as OpenAICompatibleLMInvoker, OpenAILMInvoker as OpenAILMInvoker, XAILMInvoker as XAILMInvoker
 from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker as BaseLMInvoker
 from gllm_inference.schema.model_id import ModelId as ModelId, ModelProvider as ModelProvider
 from typing import Any
@@ -144,6 +144,17 @@ def build_lm_invoker(model_id: str | ModelId, credentials: str | dict[str, Any]
         For the list of supported providers, please refer to the following page:
         https://docs.litellm.ai/docs/providers/
 
+        # Using xAI
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="xai/grok-3",
+            credentials="xai-..."
+        )
+        ```
+        The credentials can also be provided through the `XAI_API_KEY` environment variable.
+        For the list of supported models, please refer to the following page:
+        https://docs.x.ai/docs/models
+
     Security warning:
         Please provide the LM invoker credentials ONLY to the `credentials` parameter. Do not put any kind of
         credentials in the `config` parameter as the content of the `config` parameter will be logged.

gllm_inference/constants.pyi

@@ -3,6 +3,7 @@ from _typeshed import Incomplete
 DEFAULT_AZURE_OPENAI_API_VERSION: str
 DOCUMENT_MIME_TYPES: Incomplete
 GOOGLE_SCOPES: Incomplete
+GRPC_ENABLE_RETRIES_KEY: str
 INVOKER_PROPAGATED_MAX_RETRIES: int
 INVOKER_DEFAULT_TIMEOUT: float
 HEX_REPR_LENGTH: int

gllm_inference/lm_invoker/__init__.pyi

@@ -7,5 +7,6 @@ from gllm_inference.lm_invoker.langchain_lm_invoker import LangChainLMInvoker as
 from gllm_inference.lm_invoker.litellm_lm_invoker import LiteLLMLMInvoker as LiteLLMLMInvoker
 from gllm_inference.lm_invoker.openai_compatible_lm_invoker import OpenAICompatibleLMInvoker as OpenAICompatibleLMInvoker
 from gllm_inference.lm_invoker.openai_lm_invoker import OpenAILMInvoker as OpenAILMInvoker
+from gllm_inference.lm_invoker.xai_lm_invoker import XAILMInvoker as XAILMInvoker
 
-__all__ = ['AnthropicLMInvoker', 'AzureOpenAILMInvoker', 'BedrockLMInvoker', 'DatasaurLMInvoker', 'GoogleLMInvoker', 'LangChainLMInvoker', 'LiteLLMLMInvoker', 'OpenAICompatibleLMInvoker', 'OpenAILMInvoker']
+__all__ = ['AnthropicLMInvoker', 'AzureOpenAILMInvoker', 'BedrockLMInvoker', 'DatasaurLMInvoker', 'GoogleLMInvoker', 'LangChainLMInvoker', 'LiteLLMLMInvoker', 'OpenAICompatibleLMInvoker', 'OpenAILMInvoker', 'XAILMInvoker']

gllm_inference/lm_invoker/schema/xai.pyi

@@ -0,0 +1,31 @@
+from enum import StrEnum
+
+class Key:
+    """Defines valid keys in xAI."""
+    ARGUMENTS: str
+    CHANNEL_OPTIONS: str
+    CITATIONS: str
+    COMPLETION_TOKENS: str
+    CONTENT: str
+    FINISH_REASON: str
+    FUNCTION: str
+    ID: str
+    NAME: str
+    ON: str
+    PROMPT_TOKENS: str
+    REASONING_CONTENT: str
+    REASONING_EFFORT: str
+    RESPONSE_FORMAT: str
+    SEARCH_PARAMETERS: str
+    TIMEOUT: str
+    TOOL_CALLS: str
+    TOOLS: str
+    TYPE: str
+    URL: str
+    URL_CITATION: str
+    USAGE: str
+
+class ReasoningEffort(StrEnum):
+    """Defines the reasoning effort for reasoning models."""
+    HIGH = 'high'
+    LOW = 'low'

gllm_inference/lm_invoker/xai_lm_invoker.pyi

@@ -0,0 +1,303 @@
+from _typeshed import Incomplete
+from gllm_core.event import EventEmitter as EventEmitter
+from gllm_core.schema.tool import Tool as Tool
+from gllm_core.utils.retry import RetryConfig as RetryConfig
+from gllm_inference.constants import GRPC_ENABLE_RETRIES_KEY as GRPC_ENABLE_RETRIES_KEY, INVOKER_PROPAGATED_MAX_RETRIES as INVOKER_PROPAGATED_MAX_RETRIES
+from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker as BaseLMInvoker
+from gllm_inference.lm_invoker.schema.xai import Key as Key, ReasoningEffort as ReasoningEffort
+from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, EmitDataType as EmitDataType, LMOutput as LMOutput, Message as Message, MessageRole as MessageRole, ModelId as ModelId, ModelProvider as ModelProvider, Reasoning as Reasoning, ResponseSchema as ResponseSchema, TokenUsage as TokenUsage, ToolCall as ToolCall, ToolResult as ToolResult
+from gllm_inference.utils.validation import validate_string_enum as validate_string_enum
+from langchain_core.tools import Tool as LangChainTool
+from typing import Any
+
+SUPPORTED_ATTACHMENTS: Incomplete
+
+class XAILMInvoker(BaseLMInvoker):
+    '''A language model invoker to interact with xAI language models.
+
+    Attributes:
+        model_id (str): The model ID of the language model.
+        model_provider (str): The provider of the language model.
+        model_name (str): The name of the language model.
+        client_params (dict[str, Any]): The xAI client initialization parameters.
+        default_hyperparameters (dict[str, Any]): Default hyperparameters for invoking the model.
+        tools (list[Tool]): The list of tools provided to the model to enable tool calling.
+        response_schema (ResponseSchema | None): The schema of the response. If provided, the model will output a
+            structured response as defined by the schema. Supports both Pydantic BaseModel and JSON schema dictionary.
+        output_analytics (bool): Whether to output the invocation analytics.
+        retry_config (RetryConfig | None): The retry configuration for the language model.
+        reasoning_effort (ReasoningEffort | None): The reasoning effort level for reasoning models ("low" or "high").
+        web_search (bool): Whether to enable the web search.
+
+
+    Basic usage:
+        The `XAILMInvoker` can be used as follows:
+        ```python
+        lm_invoker = XAILMInvoker(model_name="grok-3")
+        result = await lm_invoker.invoke("Hi there!")
+        ```
+
+    Input types:
+        The `XAILMInvoker` supports the following input types: text and image.
+        Non-text inputs can be passed as an `Attachment` object with the `user` role.
+
+        Usage example:
+        ```python
+        text = "What animal is in this image?"
+        image = Attachment.from_path("path/to/local/image.png")
+        result = await lm_invoker.invoke([text, image])
+        ```
+
+    Tool calling:
+        Tool calling is a feature that allows the language model to call tools to perform tasks.
+        Tools can be passed to the via the `tools` parameter as a list of `Tool` objects.
+        When tools are provided and the model decides to call a tool, the tool calls are stored in the
+        `tool_calls` attribute in the output.
+
+        Usage example:
+        ```python
+        lm_invoker = XAILMInvoker(..., tools=[tool_1, tool_2])
+        ```
+
+        Output example:
+        ```python
+        LMOutput(
+            response="Let me call the tools...",
+            tool_calls=[
+                ToolCall(id="123", name="tool_1", args={"key": "value"}),
+                ToolCall(id="456", name="tool_2", args={"key": "value"}),
+            ]
+        )
+        ```
+
+    Structured output:
+        Structured output is a feature that allows the language model to output a structured response.
+        This feature can be enabled by providing a schema to the `response_schema` parameter.
+
+        The schema must be either a JSON schema dictionary or a Pydantic BaseModel class.
+        If JSON schema is used, it must be compatible with Pydantic\'s JSON schema, especially for complex schemas.
+        For this reason, it is recommended to create the JSON schema using Pydantic\'s `model_json_schema` method.
+
+        The language model also doesn\'t need to stream anything when structured output is enabled. Thus, standard
+        invocation will be performed regardless of whether the `event_emitter` parameter is provided or not.
+
+        When enabled, the structured output is stored in the `structured_output` attribute in the output.
+        1. If the schema is a JSON schema dictionary, the structured output is a dictionary.
+        2. If the schema is a Pydantic BaseModel class, the structured output is a Pydantic model.
+
+        # Example 1: Using a JSON schema dictionary
+        Usage example:
+        ```python
+        schema = {
+            "title": "Animal",
+            "description": "A description of an animal.",
+            "properties": {
+                "color": {"title": "Color", "type": "string"},
+                "name": {"title": "Name", "type": "string"},
+            },
+            "required": ["name", "color"],
+            "type": "object",
+        }
+        lm_invoker = XAILMInvoker(..., response_schema=schema)
+        ```
+        Output example:
+        ```python
+        LMOutput(structured_output={"name": "Golden retriever", "color": "Golden"})
+        ```
+
+        # Example 2: Using a Pydantic BaseModel class
+        Usage example:
+        ```python
+        class Animal(BaseModel):
+            name: str
+            color: str
+
+        lm_invoker = XAILMInvoker(..., response_schema=Animal)
+        ```
+        Output example:
+        ```python
+        LMOutput(structured_output=Animal(name="Golden retriever", color="Golden"))
+        ```
+
+    Reasoning:
+        Reasoning effort is a feature specific to xAI\'s reasoning models that allows you to control the level
+        of reasoning performed by the model. This feature can be enabled by setting the `reasoning_effort` parameter.
+        Valid values are "low" and "high".
+
+        Please note that Grok 4 does not have a `reasoning_effort` parameter. If a `reasoning_effort` is provided,
+        the request will return error.
+
+        Usage example:
+        ```python
+        lm_invoker = XAILMInvoker(
+            model_name="grok-3",
+            reasoning_effort="high"  # Enable high reasoning effort
+        )
+        ```
+
+        When reasoning effort is enabled, the model\'s internal reasoning process is captured and stored in the
+        `reasoning` attribute in the output.
+
+        Output example:
+        ```python
+        LMOutput(
+            response="The answer is 42",
+            reasoning=[
+                Reasoning(
+                    id="reasoning_1",
+                    reasoning="First, I need to understand the question. The user is asking about..."
+                )
+            ]
+        )
+        ```
+
+        When streaming is enabled along with reasoning summary, the reasoning summary token will be streamed with the
+        `EventType.DATA` event type.
+
+        Streaming output example:
+        ```python
+        {"type": "data", "value": \'{"data_type": "thinking_start", "data_value": ""}\', ...}
+        {"type": "data", "value": \'{"data_type": "thinking", "data_value": "Let me think "}\', ...}
+        {"type": "data", "value": \'{"data_type": "thinking", "data_value": "about it..."}\', ...}
+        {"type": "data", "value": \'{"data_type": "thinking_end", "data_value": ""}\', ...}
+        {"type": "response", "value": "Golden retriever ", ...}
+        {"type": "response", "value": "is a good dog breed.", ...}
+        ```
+
+        Setting reasoning-related parameters for non-reasoning models will raise an error.
+
+    Analytics tracking:
+        Analytics tracking is a feature that allows the module to output additional information about the invocation.
+        This feature can be enabled by setting the `output_analytics` parameter to `True`.
+        When enabled, the following attributes will be stored in the output:
+        1. `token_usage`: The token usage.
+        2. `finish_details`: The details about how the generation finished.
+
+        Output example:
+        ```python
+        LMOutput(
+            response="Golden retriever is a good dog breed.",
+            token_usage=TokenUsage(input_tokens=100, output_tokens=50),
+            finish_details={"finish_reason": "stop"},
+        )
+        ```
+
+        When streaming is enabled, token usage is not supported. Therefore, the `token_usage` attribute will be `None`
+        regardless of the value of the `output_analytics` parameter.
+
+    Retry and timeout:
+        The `XAILMInvoker` supports retry and timeout configuration.
+        By default, the max retries is set to 0 and the timeout is set to 30.0 seconds.
+        They can be customized by providing a custom `RetryConfig` object to the `retry_config` parameter.
+
+        Retry config examples:
+        ```python
+        retry_config = RetryConfig(max_retries=0, timeout=0.0)  # No retry, no timeout
+        retry_config = RetryConfig(max_retries=0, timeout=10.0)  # No retry, 10.0 seconds timeout
+        retry_config = RetryConfig(max_retries=5, timeout=0.0)  # 5 max retries, no timeout
+        retry_config = RetryConfig(max_retries=5, timeout=10.0)  # 5 max retries, 10.0 seconds timeout
+        ```
+
+        Usage example:
+        ```python
+        lm_invoker = XAILMInvoker(..., retry_config=retry_config)
+        ```
+
+    Web Search:
+        The web search is a feature that allows the language model to search the web for relevant information.
+        This feature can be enabled by setting the `web_search` parameter to `True`.
+
+        Usage example:
+        ```python
+        lm_invoker = XAILMInvoker(
+            model_name="grok-3",
+            web_search=True
+        )
+        ```
+
+        When web search is enabled, the language model will search for relevant information and may cite the
+        relevant sources (including from X platform). The citations will be stored as `Chunk` objects in the `citations`
+        attribute in the output.
+
+        Output example:
+        ```python
+        LMOutput(
+            response="According to recent reports, the latest AI developments include... ([Source](https://example.com)).",
+            citations=[
+                Chunk(
+                    id="search_result_1",
+                    content="Latest AI developments report",
+                    metadata={
+                        "start_index": 164,
+                        "end_index": 275,
+                        "title": "Example title",
+                        "url": "https://www.example.com",
+                        "type": "url_citation",
+                    },
+                ),
+            ],
+        )
+        ```
+
+        When streaming is enabled, the live search activities will be streamed with the `EventType.DATA` event type.
+        This allows you to track the search process in real-time.
+
+        Streaming output example:
+        ```python
+        {"type": "data", "value": \'{"data_type": "activity", "data_value": "{\\"query\\": \\"search query\\"}", ...}\', ...}
+        {"type": "response", "value": "According to recent reports, ", ...}
+        {"type": "response", "value": "the latest AI developments include...", ...}
+        ```
+
+    Output types:
+        The output of the `XAILMInvoker` can either be:
+        1. `str`: The text response if no additional output is needed.
+        2. `LMOutput`: A Pydantic model with the following attributes if any additional output is needed:
+            2.1. response (str): The text response.
+            2.2. tool_calls (list[ToolCall]): The tool calls, if the `tools` parameter is defined and the language
+                model decides to invoke tools. Defaults to an empty list.
+            2.3. structured_output (dict[str, Any] | BaseModel | None): The structured output, if the `response_schema`
+                parameter is defined. Defaults to None.
+            2.4. token_usage (TokenUsage | None): The token usage analytics, if the `output_analytics` parameter is
+                set to `True`. Defaults to None.
+            2.5. duration (float | None): The duration of the invocation in seconds, if the `output_analytics`
+                parameter is set to `True`. Defaults to None.
+            2.6. finish_details (dict[str, Any] | None): The details about how the generation finished, if the
+                `output_analytics` parameter is set to `True`. Defaults to None.
+            2.7. reasoning (list[Reasoning]): The reasoning objects, if the `reasoning_effort` parameter is set.
+                Defaults to an empty list.
+            2.8. citations (list[Chunk]): The citations, if the web_search is enabled and the language model decides
+                to cite the relevant sources. Defaults to an empty list.
+            2.9. code_exec_results (list[CodeExecResult]): The code execution results. Currently not supported.
+                Defaults to an empty list.
+    '''
+    reasoning_effort: Incomplete
+    web_search: Incomplete
+    client_params: Incomplete
+    def __init__(self, model_name: str, api_key: str | None = None, model_kwargs: dict[str, Any] | None = None, default_hyperparameters: dict[str, Any] | None = None, tools: list[Tool | LangChainTool] | None = None, response_schema: ResponseSchema | None = None, output_analytics: bool = False, retry_config: RetryConfig | None = None, reasoning_effort: ReasoningEffort | None = None, web_search: bool = False) -> None:
+        """Initializes a new instance of the XAILMInvoker class.
+
+        Args:
+            model_name (str): The name of the xAI model.
+            api_key (str | None, optional): The API key for authenticating with xAI. Defaults to None, in which
+                case the `XAI_API_KEY` environment variable will be used.
+            model_kwargs (dict[str, Any] | None, optional): Additional model parameters. Defaults to None.
+            default_hyperparameters (dict[str, Any] | None, optional): Default hyperparameters for invoking the model.
+                Defaults to None.
+            tools (list[Tool | LangChainTool] | None, optional): Tools provided to the language model to enable tool
+            calling.
+                Defaults to None.
+            response_schema (ResponseSchema | None, optional): The schema of the response. If provided, the model will
+                output a structured response as defined by the schema. Supports both Pydantic BaseModel and JSON schema
+                dictionary. Defaults to None.
+            output_analytics (bool, optional): Whether to output the invocation analytics. Defaults to False.
+            retry_config (RetryConfig | None, optional): The retry configuration for the language model.
+                Defaults to None, in which case a default config with no retry and 30.0 seconds timeout is used.
+            reasoning_effort (ReasoningEffort | None, optional): The reasoning effort for reasoning models. Not allowed
+                for non-reasoning models. If None, the model will perform medium reasoning effort. Defaults to None.
+            web_search (bool, optional): Whether to enable the web search. Defaults to False.
+
+        Raises:
+            ValueError:
+            1. `reasoning_effort` is provided, but is not a valid ReasoningEffort.
+        """

gllm_inference/request_processor/lm_request_processor.pyi

@@ -60,7 +60,7 @@ class LMRequestProcessor:
 
         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) -> Any:
+    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:
@@ -72,8 +72,8 @@ class LMRequestProcessor:
            LMOutput object, the output parser will process the `response` attribute of the LMOutput object.
 
         Args:
-            prompt_kwargs (dict[str, Any], optional): A dictionary of arguments used to format the prompt.
-                Defaults to None, in which case no arguments will be passed to the prompt builder.
+            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
@@ -86,6 +86,15 @@ class LMRequestProcessor:
                 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/schema/model_id.pyi

@@ -19,6 +19,7 @@ class ModelProvider(StrEnum):
     OPENAI_COMPATIBLE = 'openai-compatible'
     TWELVELABS = 'twelvelabs'
     VOYAGE = 'voyage'
+    XAI = 'xai'
 
 class ModelId(BaseModel):
     '''Defines a representation of a valid model id.
@@ -88,12 +89,20 @@ class ModelId(BaseModel):
         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-3-5-sonnet-latest"},
             ModelProvider.GOOGLE: {"gemini-1.5-flash", "gemini-1.5-pro"},
             ModelProvider.OPENAI: {"gpt-4o", "gpt-4o-mini"},
+        }
 
         model_id = ModelId.from_string("...", validation_map)
         ```

gllm_inference/schema/type_alias.pyi

@@ -1,5 +1,5 @@
 from aiohttp import ClientResponse
-from gllm_inference.schema.code_exec_result import Attachment as Attachment
+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

gllm_inference.pyi

@@ -28,6 +28,7 @@ import gllm_inference.lm_invoker.LangChainLMInvoker
 import gllm_inference.lm_invoker.LiteLLMLMInvoker
 import gllm_inference.lm_invoker.OpenAICompatibleLMInvoker
 import gllm_inference.lm_invoker.OpenAILMInvoker
+import gllm_inference.lm_invoker.XAILMInvoker
 import gllm_inference.prompt_builder.PromptBuilder
 import gllm_inference.output_parser.JSONOutputParser
 import json
@@ -100,6 +101,12 @@ import langchain_core.utils.function_calling
 import gllm_inference.schema.MessageContent
 import gllm_inference.utils.validate_string_enum
 import gllm_inference.schema.CodeExecResult
+import xai_sdk
+import xai_sdk.chat
+import xai_sdk.search
+import xai_sdk.proto
+import xai_sdk.proto.v6
+import xai_sdk.proto.v6.chat_pb2
 import transformers
 import gllm_inference.prompt_formatter.HuggingFacePromptFormatter
 import gllm_core.utils.logger_manager

{gllm_inference_binary-0.5.12.dist-info → gllm_inference_binary-0.5.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gllm-inference-binary
-Version: 0.5.12
+Version: 0.5.14
 Summary: A library containing components related to model inferences in Gen AI applications.
 Author: Henry Wicaksono
 Author-email: henry.wicaksono@gdplabs.id
@@ -17,6 +17,7 @@ Provides-Extra: litellm
 Provides-Extra: openai
 Provides-Extra: twelvelabs
 Provides-Extra: voyage
+Provides-Extra: xai
 Requires-Dist: aioboto3 (>=15.0.0,<16.0.0) ; extra == "bedrock"
 Requires-Dist: aiohttp (>=3.12.14,<4.0.0)
 Requires-Dist: anthropic (>=0.60.0,<0.61.0) ; extra == "anthropic"
@@ -32,13 +33,14 @@ Requires-Dist: litellm (>=1.69.2,<2.0.0) ; extra == "litellm"
 Requires-Dist: openai (>=1.98.0,<2.0.0) ; extra == "datasaur" or extra == "openai"
 Requires-Dist: pandas (>=2.2.3,<3.0.0)
 Requires-Dist: poetry (>=2.1.3,<3.0.0)
-Requires-Dist: protobuf (>=5.28.2,<6.0.0)
+Requires-Dist: protobuf (>=6.0.0,<7.0.0)
 Requires-Dist: python-magic (>=0.4.27,<0.5.0) ; sys_platform != "win32"
 Requires-Dist: python-magic-bin (>=0.4.14,<0.5.0) ; sys_platform == "win32"
 Requires-Dist: sentencepiece (>=0.2.0,<0.3.0)
 Requires-Dist: transformers (==4.52.4) ; extra == "huggingface"
 Requires-Dist: twelvelabs (>=0.4.4,<0.5.0) ; extra == "twelvelabs"
 Requires-Dist: voyageai (>=0.3.0,<0.4.0) ; (python_version < "3.13") and (extra == "voyage")
+Requires-Dist: xai_sdk (>=1.0.0,<2.0.0) ; extra == "xai"
 Description-Content-Type: text/markdown
 
 # GLLM Inference

{gllm_inference_binary-0.5.12.dist-info → gllm_inference_binary-0.5.14.dist-info}/RECORD

@@ -1,14 +1,14 @@
 gllm_inference/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gllm_inference/builder/__init__.pyi,sha256=usz2lvfwO4Yk-ZGKXbCWG1cEr3nlQXxMNDNC-2yc1NM,500
 gllm_inference/builder/build_em_invoker.pyi,sha256=YL71GriZEXn4uxmXBJHWC200QdWRPwUJY_G0kKi5-dk,5352
-gllm_inference/builder/build_lm_invoker.pyi,sha256=aXdNU1gUBUz-4jZ-P791tlkmjOOInLYyeiveEJFlYZo,6468
+gllm_inference/builder/build_lm_invoker.pyi,sha256=igJdLnWiY5QcdT4EClvgxFGSVZjARpq5hz2FYcBHWEQ,6876
 gllm_inference/builder/build_lm_request_processor.pyi,sha256=33Gi3onftl-V2e_mkJios5zmXRKSoAVPX3UK7YBExjk,4491
 gllm_inference/builder/build_output_parser.pyi,sha256=_Lrq-bh1oPsb_Nwkkr_zyEUwIOMysRFZkvEtEM29LZM,936
 gllm_inference/catalog/__init__.pyi,sha256=JBkPGTyiiZ30GECzJBW-mW8LekWyY2qyzal3eW7ynaM,287
 gllm_inference/catalog/catalog.pyi,sha256=a4RNG1lKv51GxQpOqh47tz-PAROMPaeP2o5XNLBSZaU,4790
 gllm_inference/catalog/lm_request_processor_catalog.pyi,sha256=ranHMbG9--DZj9FJRhIUa6U8e-L-Tm-_hSBpzJ6DDs4,5428
 gllm_inference/catalog/prompt_builder_catalog.pyi,sha256=OU8k_4HbqjZEzHZlzSM3uzGQZJmM2uGD76Csqom0CEQ,3197
-gllm_inference/constants.pyi,sha256=JDSc_GdTGg2RVlwM9Jy-2dtC4a5311KcE1WHdnUMmt4,285
+gllm_inference/constants.pyi,sha256=KDzHmjVYjd0uTHqLgIzgHhLZx99D8jGBIg74eO8KQv0,314
 gllm_inference/em_invoker/__init__.pyi,sha256=XESsrYo1PZeeHe7AMRyuzKoV7XDD5oN89ZTH01zRf4k,873
 gllm_inference/em_invoker/azure_openai_em_invoker.pyi,sha256=OEkVu5nv92ITqdhDtgDg4MiLSDRWDmLSnAhYtXpCn6E,4602
 gllm_inference/em_invoker/em_invoker.pyi,sha256=hiH8FB5R-KxhI8Ds2htF3cjRcIcH92yHPcOdpgc4FDo,4341
@@ -30,7 +30,7 @@ gllm_inference/em_invoker/voyage_em_invoker.pyi,sha256=7akaf8GxOA8Trokad0xmlYKr4
 gllm_inference/exceptions/__init__.pyi,sha256=v9uxjW5DssIn7n_bKqT7L83CeqFET2Z45GFOvi78UuE,977
 gllm_inference/exceptions/error_parser.pyi,sha256=4RkVfS2Fl9kjz_h2bK9eoAeI-Y-VkHcUqXWj68BsYig,2393
 gllm_inference/exceptions/exceptions.pyi,sha256=5YRackwVNvyOJjOtiVszqu8q87s8ioXTa-XwaYmeiC4,4643
-gllm_inference/lm_invoker/__init__.pyi,sha256=8oUFgavpItvjRUqsLqLSHqQVIPyTKCgNQ_euf58H2zY,1104
+gllm_inference/lm_invoker/__init__.pyi,sha256=NmQSqObPjevEP1KbbrNnaz4GMh175EVPERZ19vK5Emc,1202
 gllm_inference/lm_invoker/anthropic_lm_invoker.pyi,sha256=MsF3OmDo0L9aEHuTJYTgsoDILi2B_IgKtPpDcDMduWc,14925
 gllm_inference/lm_invoker/azure_openai_lm_invoker.pyi,sha256=EV_yrj6mnV_rCDEqSZaIikfw76_rXXyDlC-w_y-m7K0,14603
 gllm_inference/lm_invoker/bedrock_lm_invoker.pyi,sha256=IuLxgCThOSBHx1AXqnhL6yVu5_JV6hAeGBWWm5P1JCo,12423
@@ -49,6 +49,8 @@ gllm_inference/lm_invoker/schema/google.pyi,sha256=AIsNgq0ZZuicHmx4bL7z6q-946T05
 gllm_inference/lm_invoker/schema/langchain.pyi,sha256=l2kHU7S3vmG3-NCt8B26krp_i4Br3waES_CekkgrKSA,409
 gllm_inference/lm_invoker/schema/openai.pyi,sha256=w_XSzOohX_7vnR81hVXdgDbBqk737LmMAN_AvODGk2I,1902
 gllm_inference/lm_invoker/schema/openai_compatible.pyi,sha256=m3bL2hVpxI_crURIi1bGDUqMy1Z5OgKBVU_-BkhX1mg,1166
+gllm_inference/lm_invoker/schema/xai.pyi,sha256=cWnbJmDtllqRH3NXpQbiXgkNBcUXr8ksDSDywcgJebE,632
+gllm_inference/lm_invoker/xai_lm_invoker.pyi,sha256=wPzjSLLiPb4DB1gJjtCs6URPUN0JCDcIxeNRsmD6tbo,15420
 gllm_inference/model/__init__.pyi,sha256=qClHIgljqhPPCKlGTKmHsWgYb4_hADybxtC2q1U8a5Q,593
 gllm_inference/model/em/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gllm_inference/model/em/google_em.pyi,sha256=ZPN5LmReO0bcTfnZixFooUTzgD-daNFPzfxzZ-5WzQQ,471
@@ -72,7 +74,7 @@ gllm_inference/prompt_formatter/mistral_prompt_formatter.pyi,sha256=DgFitxfvCSJf
 gllm_inference/prompt_formatter/openai_prompt_formatter.pyi,sha256=QB7gHddipQuAolUKO01ApZeaRxBtRZzglS5B78mzsV8,1286
 gllm_inference/prompt_formatter/prompt_formatter.pyi,sha256=UkcPi5ao98OGJyNRsqfhYTlMW-ZLNITaGZUTwzvBzqk,1146
 gllm_inference/request_processor/__init__.pyi,sha256=hVnfdNZnkTBJHnmLtN3Na4ANP0yK6AstWdIizVr2Apo,227
-gllm_inference/request_processor/lm_request_processor.pyi,sha256=7pVNb2GwITb1jTflZP498qZ321G15b16jayZuuhuO1o,5424
+gllm_inference/request_processor/lm_request_processor.pyi,sha256=VnYc8E3Iayyhw-rPnGPfTKuO3ohgFsS8HPrZJeyES5I,5889
 gllm_inference/request_processor/uses_lm_mixin.pyi,sha256=He-ytjwv2H5Hn312WFBAlBK96ALKTtDO3AT_80hCGTg,2321
 gllm_inference/schema/__init__.pyi,sha256=aQx7eKVsFNgJkYtbbKppa9Ww2WfTe0yzl_ewajDCo6w,1363
 gllm_inference/schema/attachment.pyi,sha256=jApuzjOHJDCz4lr4MlHzBgIndh559nbWu2Xp1fk3hso,3297
@@ -80,18 +82,18 @@ gllm_inference/schema/code_exec_result.pyi,sha256=ZTHh6JtRrPIdQ059P1UAiD2L-tAO1_
 gllm_inference/schema/enums.pyi,sha256=Nvc_Qsd8yyiH_tCtymN39O6EZ0DT_wxYHmlKLllxC00,605
 gllm_inference/schema/lm_output.pyi,sha256=GafJV0KeD-VSwWkwG1oz-uruXrQ7KDZTuoojPCBRpg8,1956
 gllm_inference/schema/message.pyi,sha256=VP9YppKj2mo1esl9cy6qQO9m2mMHUjTmfGDdyUor880,2220
-gllm_inference/schema/model_id.pyi,sha256=XFfIkfetFamwVxmUifMZLehuvTcASkK7kp4OMNcteo8,5230
+gllm_inference/schema/model_id.pyi,sha256=0UJS7M91hPlzWuZI3CMGZm9ewYrTxmLUMtIhHqJOg0Q,5481
 gllm_inference/schema/reasoning.pyi,sha256=SlTuiDw87GdnAn-I6YOPIJRhEBiwQljM46JohG05guQ,562
 gllm_inference/schema/token_usage.pyi,sha256=1GTQVORV0dBNmD_jix8aVaUqxMKFF04KpLP7y2urqbk,2950
 gllm_inference/schema/tool_call.pyi,sha256=zQaVxCnkVxOfOEhBidqohU85gb4PRwnwBiygKaunamk,389
 gllm_inference/schema/tool_result.pyi,sha256=cAG7TVtB4IWJPt8XBBbB92cuY1ZsX9M276bN9aqjcvM,276
-gllm_inference/schema/type_alias.pyi,sha256=CkqX5zLML4vII7BEIXDz7ZQd211RsHtq7EJekkV2V6g,725
+gllm_inference/schema/type_alias.pyi,sha256=cQRlLT5vz9YV50n9x5BmufgqUz0UByInpmAvHSv2WTY,719
 gllm_inference/utils/__init__.pyi,sha256=npmBmmlBv7cPHMg1hdL3S2_RelD6vk_LhCsGELhN_7s,295
 gllm_inference/utils/langchain.pyi,sha256=VluQiHkGigDdqLUbhB6vnXiISCP5hHqV0qokYY6dC1A,1164
 gllm_inference/utils/validation.pyi,sha256=toxBtRp-VItC_X7sNi-GDd7sjibBdWMrR0q01OI2D7k,385
 gllm_inference.build/.gitignore,sha256=aEiIwOuxfzdCmLZe4oB1JsBmCUxwG8x-u-HBCV9JT8E,1
-gllm_inference.cpython-311-darwin.so,sha256=vcBtD-Siqa9emWBgnePoUGlgNcmoubGFm5DfmGMHbLc,3850968
-gllm_inference.pyi,sha256=HKpIBBH4eG78VMFJinhhYVwVhZdE6DNA-viLpA7HIw4,3339
-gllm_inference_binary-0.5.12.dist-info/METADATA,sha256=9B_Z5J3mbp5q_5wO_Xu3VX6w5HSnrI8wfoSckKH9CqA,4532
-gllm_inference_binary-0.5.12.dist-info/WHEEL,sha256=r3EiIdyNg8wC0u2K9wWWq7Elb6S4XGGmkyBqljSOtNU,107
-gllm_inference_binary-0.5.12.dist-info/RECORD,,
+gllm_inference.cpython-311-darwin.so,sha256=vS30uoSG5DYuj3QlbTKEQZ5cQ7r5ILVfbV0y882tyPM,4050952
+gllm_inference.pyi,sha256=Ho74MJb64Q0MQI7xTOf7pmM675HXs3ZQfLKg2kmusDg,3520
+gllm_inference_binary-0.5.14.dist-info/METADATA,sha256=_PX1mmZ2KxIQu7Tp9zlYLjTwSBl0UzG9ewo8UPe5y6w,4608
+gllm_inference_binary-0.5.14.dist-info/WHEEL,sha256=r3EiIdyNg8wC0u2K9wWWq7Elb6S4XGGmkyBqljSOtNU,107
+gllm_inference_binary-0.5.14.dist-info/RECORD,,