gllm-inference-binary 0.5.34__cp311-cp311-win_amd64.whl → 0.5.35__cp311-cp311-win_amd64.whl

gllm_inference/builder/build_em_invoker.pyi

@@ -24,11 +24,8 @@ def build_em_invoker(model_id: str | ModelId, credentials: str | dict[str, Any]
     '''Build an embedding model invoker based on the provided configurations.
 
     Args:
-        model_id (str | ModelId): The model id, can either be a ModelId instance or a string in the following format:
-            1. For `azure-openai` provider: `azure-openai/azure-endpoint:azure-deployment`.
-            2. For `openai-compatible` provider: `openai-compatible/base-url:model-name`.
-            3. For `langchain` provider: `langchain/<package>.<class>:model-name`.
-            4. For other providers: `provider/model-name`.
+        model_id (str | ModelId): The model id, can either be a ModelId instance or a string in a format defined
+            in the following page: https://gdplabs.gitbook.io/sdk/resources/supported-models#embedding-models-ems
         credentials (str | dict[str, Any] | None, optional): The credentials for the language model. Can either be:
             1. An API key.
             2. A path to a credentials JSON file, currently only supported for Google Vertex AI.
@@ -83,23 +80,23 @@ def build_em_invoker(model_id: str | ModelId, credentials: str | dict[str, Any]
         ```
         The credentials can also be provided through the `OPENAI_API_KEY` environment variable.
 
-        # Using Azure OpenAI
+        # Using OpenAI Embeddings API-compatible endpoints (e.g. vLLM)
         ```python
         em_invoker = build_em_invoker(
-            model_id="azure-openai/https://my-resource.openai.azure.com/openai/v1:my-deployment",
-            credentials="azure-api-key"
+            model_id="openai/https://my-vllm-url:8000/v1:my-model-name",
+            credentials="sk-..."
         )
         ```
-        The credentials can also be provided through the `AZURE_OPENAI_API_KEY` environment variable.
+        The credentials can also be provided through the `OPENAI_API_KEY` environment variable.
 
-        # Using OpenAI Compatible endpoint (e.g. Text Embeddings Inference)
+        # Using Azure OpenAI
         ```python
         em_invoker = build_em_invoker(
-            model_id="openai-compatible/https://my-text-embeddings-inference-endpoint.com:model-name",
-            credentials="tei-api-key"
+            model_id="azure-openai/https://my-resource.openai.azure.com/openai/v1:my-deployment",
+            credentials="azure-api-key"
         )
         ```
-        The credentials can also be provided through the `OPENAI_API_KEY` environment variable.
+        The credentials can also be provided through the `AZURE_OPENAI_API_KEY` environment variable.
 
         # Using TwelveLabs
         ```python

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, XAILMInvoker as XAILMInvoker
+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, OpenAIChatCompletionsLMInvoker as OpenAIChatCompletionsLMInvoker, 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
@@ -25,13 +25,8 @@ def build_lm_invoker(model_id: str | ModelId, credentials: str | dict[str, Any]
     '''Build a language model invoker based on the provided configurations.
 
     Args:
-        model_id (str | ModelId): The model id, can either be a ModelId instance or a string in the following format:
-            1. For `azure-openai` provider: `azure-openai/azure-endpoint:azure-deployment`.
-            2. For `openai-compatible` provider: `openai-compatible/base-url:model-name`.
-            3. For `langchain` provider: `langchain/<package>.<class>:model-name`.
-            4. For `litellm` provider: `litellm/provider/model-name`.
-            5. For `datasaur` provider: `datasaur/deployment-id:model-name`.
-            6. For other providers: `provider/model-name`.
+        model_id (str | ModelId): The model id, can either be a ModelId instance or a string in a format defined
+            in the following page: https://gdplabs.gitbook.io/sdk/resources/supported-models#language-models-lms
         credentials (str | dict[str, Any] | None, optional): The credentials for the language model. Can either be:
             1. An API key.
             2. A path to a credentials JSON file, currently only supported for Google Vertex AI.
@@ -80,7 +75,7 @@ def build_lm_invoker(model_id: str | ModelId, credentials: str | dict[str, Any]
         # Using Google Gen AI (via API key)
         ```python
         lm_invoker = build_lm_invoker(
-            model_id="google/gemini-1.5-flash-latest",
+            model_id="google/gemini-2.5-flash-lite",
             credentials="AIzaSyD..."
         )
         ```
@@ -89,7 +84,7 @@ def build_lm_invoker(model_id: str | ModelId, credentials: str | dict[str, Any]
         # Using Google Vertex AI (via service account)
         ```python
         lm_invoker = build_lm_invoker(
-            model_id="google/gemini-1.5-flash",
+            model_id="google/gemini-2.5-flash-lite",
             credentials="/path/to/google-credentials.json"
         )
         ```
@@ -98,30 +93,48 @@ def build_lm_invoker(model_id: str | ModelId, credentials: str | dict[str, Any]
         # Using OpenAI
         ```python
         lm_invoker = build_lm_invoker(
-            model_id="openai/gpt-4o-mini",
+            model_id="openai/gpt-5-nano",
             credentials="sk-..."
         )
         ```
         The credentials can also be provided through the `OPENAI_API_KEY` environment variable.
 
-        # Using Azure OpenAI
+        # Using OpenAI with Chat Completions API
         ```python
         lm_invoker = build_lm_invoker(
-            model_id="azure-openai/https://my-resource.openai.azure.com/openai/v1:my-deployment",
-            credentials="azure-api-key"
+            model_id="openai-chat-completions/gpt-5-nano",
+            credentials="sk-..."
         )
         ```
-        The credentials can also be provided through the `AZURE_OPENAI_API_KEY` environment variable.
+        The credentials can also be provided through the `OPENAI_API_KEY` environment variable.
+
+        # Using OpenAI Responses API-compatible endpoints (e.g. SGLang)
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="openai/https://my-sglang-url:8000/v1:my-model-name",
+            credentials="sk-..."
+        )
+        ```
+        The credentials can also be provided through the `OPENAI_API_KEY` environment variable.
 
-        # Using OpenAI Compatible endpoint (e.g. Groq)
+        # Using OpenAI Chat Completions API-compatible endpoints (e.g. Groq)
         ```python
         lm_invoker = build_lm_invoker(
-            model_id="openai-compatible/https://api.groq.com/openai/v1:llama3-8b-8192",
+            model_id="openai-chat-completions/https://api.groq.com/openai/v1:llama3-8b-8192",
             credentials="gsk_..."
         )
         ```
         The credentials can also be provided through the `OPENAI_API_KEY` environment variable.
 
+        # Using Azure OpenAI
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="azure-openai/https://my-resource.openai.azure.com/openai/v1:my-deployment",
+            credentials="azure-api-key"
+        )
+        ```
+        The credentials can also be provided through the `AZURE_OPENAI_API_KEY` environment variable.
+
         # Using LangChain
         ```python
         lm_invoker = build_lm_invoker(

gllm_inference/builder/build_lm_request_processor.pyi

@@ -12,13 +12,8 @@ def build_lm_request_processor(model_id: str | ModelId, credentials: str | dict[
     '''Build a language model invoker based on the provided configurations.
 
     Args:
-        model_id (str | ModelId): The model id, can either be a ModelId instance or a string in the following format:
-            1. For `azure-openai` provider: `azure-openai/azure-endpoint:azure-deployment`.
-            2. For `openai-compatible` provider: `openai-compatible/base-url:model-name`.
-            3. For `langchain` provider: `langchain/<package>.<class>:model-name`.
-            4. For `litellm` provider: `litellm/provider/model-name`.
-            5. For `datasaur` provider: `datasaur/base-url`.
-            6. For other providers: `provider/model-name`.
+        model_id (str | ModelId): The model id, can either be a ModelId instance or a string in a format defined
+            in the following page: https://gdplabs.gitbook.io/sdk/resources/supported-models#language-models-lms
         credentials (str | dict[str, Any] | None, optional): The credentials for the language model. Can either be:
             1. An API key.
             2. A path to a credentials JSON file, currently only supported for Google Vertex AI.

gllm_inference/catalog/lm_request_processor_catalog.pyi

@@ -57,7 +57,7 @@ class LMRequestProcessorCatalog(BaseCatalog[LMRequestProcessor]):
                 ),
                 "user_template": "{query}",
                 "key_defaults": \'{"context": "<default context>"}\',
-                "model_id": "openai/gpt-4.1-nano",
+                "model_id": "openai/gpt-5-nano",
                 "credentials": "OPENAI_API_KEY",
                 "config": "",
                 "output_parser_type": "none",
@@ -93,7 +93,7 @@ class LMRequestProcessorCatalog(BaseCatalog[LMRequestProcessor]):
             prompt template keys. These default values will be applied when the corresponding keys are not provided
             in the runtime input. If it is empty, the prompt template keys will not have default values.
         3. The `model_id`:
-            3.1. Must be filled with the model ID of the LM invoker, e.g. "openai/gpt-4.1-nano".
+            3.1. Must be filled with the model ID of the LM invoker, e.g. "openai/gpt-5-nano".
             3.2. Can be partially loaded from the environment variable using the "${ENV_VAR_KEY}" syntax,
                 e.g. "azure-openai/${AZURE_ENDPOINT}/${AZURE_DEPLOYMENT}".
             3.3. For the available model ID formats, see: https://gdplabs.gitbook.io/sdk/resources/supported-models

gllm_inference/constants.pyi

@@ -7,4 +7,5 @@ GRPC_ENABLE_RETRIES_KEY: str
 INVOKER_PROPAGATED_MAX_RETRIES: int
 INVOKER_DEFAULT_TIMEOUT: float
 HEX_REPR_LENGTH: int
+OPENAI_DEFAULT_URL: str
 SECONDS_TO_MILLISECONDS: int

gllm_inference/em_invoker/openai_compatible_em_invoker.pyi

@@ -6,8 +6,10 @@ from gllm_inference.em_invoker.schema.openai_compatible import Key as Key
 from gllm_inference.schema import ModelId as ModelId, ModelProvider as ModelProvider, TruncationConfig as TruncationConfig
 from typing import Any
 
+DEPRECATION_MESSAGE: str
+
 class OpenAICompatibleEMInvoker(OpenAIEMInvoker):
-    '''An embedding model invoker to interact with endpoints compatible with OpenAI\'s embedding API contract.
+    """An embedding model invoker to interact with endpoints compatible with OpenAI's embedding API contract.
 
     Attributes:
         model_id (str): The model ID of the embedding model.
@@ -18,65 +20,8 @@ class OpenAICompatibleEMInvoker(OpenAIEMInvoker):
         retry_config (RetryConfig): The retry configuration for the embedding model.
         truncation_config (TruncationConfig | None): The truncation configuration for the embedding model.
 
-
-    When to use:
-        The `OpenAICompatibleEMInvoker` is designed to interact with endpoints that are compatible with OpenAI\'s
-        embedding API contract. This includes but are not limited to:
-        1. Text Embeddings Inference (https://github.com/huggingface/text-embeddings-inference)
-        2. vLLM (https://vllm.ai/)
-        When using this invoker, please note that the supported features and capabilities may vary between different
-        endpoints and language models. Using features that are not supported by the endpoint will result in an error.
-
-    Input types:
-        The `OpenAICompatibleEMInvoker` only supports text inputs.
-
-    Output format:
-        The `OpenAICompatibleEMInvoker` can embed either:
-        1. A single content.
-           1. A single content is a single text.
-           2. The output will be a `Vector`, representing the embedding of the content.
-
-           # Example 1: Embedding a text content.
-           ```python
-           text = "This is a text"
-           result = await em_invoker.invoke(text)
-           ```
-
-           The above examples will return a `Vector` with a size of (embedding_size,).
-
-        2. A list of contents.
-           1. A list of contents is a list of texts.
-           2. The output will be a `list[Vector]`, where each element is a `Vector` representing the
-              embedding of each single content.
-
-           # Example: Embedding a list of contents.
-           ```python
-           text1 = "This is a text"
-           text2 = "This is another text"
-           text3 = "This is yet another text"
-           result = await em_invoker.invoke([text1, text2, text3])
-           ```
-
-           The above examples will return a `list[Vector]` with a size of (3, embedding_size).
-
-    Retry and timeout:
-        The `OpenAICompatibleEMInvoker` 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
-        em_invoker = OpenAICompatibleEMInvoker(..., retry_config=retry_config)
-        ```
-    '''
+    This class is deprecated and will be removed in v0.6. Please use the `OpenAIEMInvoker` class instead.
+    """
     client: Incomplete
     def __init__(self, model_name: str, base_url: str, api_key: str | None = None, model_kwargs: dict[str, Any] | None = None, default_hyperparameters: dict[str, Any] | None = None, retry_config: RetryConfig | None = None, truncation_config: TruncationConfig | None = None) -> None:
         """Initializes a new instance of the OpenAICompatibleEMInvoker class.

gllm_inference/em_invoker/openai_em_invoker.pyi

@@ -1,6 +1,6 @@
 from _typeshed import Incomplete
 from gllm_core.utils.retry import RetryConfig as RetryConfig
-from gllm_inference.constants import INVOKER_PROPAGATED_MAX_RETRIES as INVOKER_PROPAGATED_MAX_RETRIES
+from gllm_inference.constants import INVOKER_PROPAGATED_MAX_RETRIES as INVOKER_PROPAGATED_MAX_RETRIES, OPENAI_DEFAULT_URL as OPENAI_DEFAULT_URL
 from gllm_inference.em_invoker.em_invoker import BaseEMInvoker as BaseEMInvoker
 from gllm_inference.em_invoker.schema.openai import Key as Key
 from gllm_inference.schema import ModelId as ModelId, ModelProvider as ModelProvider, Vector as Vector
@@ -21,6 +21,31 @@ class OpenAIEMInvoker(BaseEMInvoker):
         retry_config (RetryConfig): The retry configuration for the embedding model.
         truncation_config (TruncationConfig | None): The truncation configuration for the embedding model.
 
+    Basic usage:
+        The `OpenAIEMInvoker` can be used as follows:
+        ```python
+        em_invoker = OpenAIEMInvoker(model_name="text-embedding-3-small")
+        result = await em_invoker.invoke("Hi there!")
+        ```
+
+    OpenAI compatible endpoints:
+        The `OpenAIEMInvoker` can also be used to interact with endpoints that are compatible with
+        OpenAI\'s Embeddings API schema. This includes but are not limited to:
+        1. Text Embeddings Inference (https://github.com/huggingface/text-embeddings-inference)
+        2. vLLM (https://vllm.ai/)
+        Please note that the supported features and capabilities may vary between different endpoints and
+        language models. Using features that are not supported by the endpoint will result in an error.
+
+        This customization can be done by setting the `base_url` parameter to the base URL of the endpoint:
+        ```python
+        em_invoker = OpenAIEMInvoker(
+            model_name="<model-name>",
+            api_key="<your-api-key>",
+            base_url="<https://base-url>",
+        )
+        result = await em_invoker.invoke("Hi there!")
+        ```
+
     Input types:
         The `OpenAIEMInvoker` only supports text inputs.
 
@@ -72,13 +97,16 @@ class OpenAIEMInvoker(BaseEMInvoker):
         ```
     '''
     client: 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, retry_config: RetryConfig | None = None, truncation_config: TruncationConfig | None = None) -> None:
-        """Initializes a new instance of the OpenAIEMInvoker class.
+    def __init__(self, model_name: str, api_key: str | None = None, base_url: str = ..., model_kwargs: dict[str, Any] | None = None, default_hyperparameters: dict[str, Any] | None = None, retry_config: RetryConfig | None = None, truncation_config: TruncationConfig | None = None) -> None:
+        '''Initializes a new instance of the OpenAIEMInvoker class.
 
         Args:
             model_name (str): The name of the OpenAI embedding model to be used.
-            api_key (str | None, optional): The API key for the OpenAI API. Defaults to None, in which
-                case the `OPENAI_API_KEY` environment variable will be used.
+            api_key (str | None, optional): The API key for authenticating with OpenAI. Defaults to None, in which
+                case the `OPENAI_API_KEY` environment variable will be used. If the endpoint does not require an
+                API key, a dummy value can be passed (e.g. "<empty>").
+            base_url (str, optional): The base URL of a custom endpoint that is compatible with OpenAI\'s
+                Embeddings API schema. Defaults to OpenAI\'s default URL.
             model_kwargs (dict[str, Any] | None, optional): Additional keyword arguments for the OpenAI client.
                 Defaults to None.
             default_hyperparameters (dict[str, Any] | None, optional): Default hyperparameters for invoking the model.
@@ -87,4 +115,4 @@ class OpenAIEMInvoker(BaseEMInvoker):
                 Defaults to None, in which case a default config with no retry and 30.0 seconds timeout will be used.
             truncation_config (TruncationConfig | None, optional): Configuration for text truncation behavior.
                 Defaults to None, in which case no truncation is applied.
-        """
+        '''

gllm_inference/lm_invoker/__init__.pyi

@@ -5,8 +5,9 @@ from gllm_inference.lm_invoker.datasaur_lm_invoker import DatasaurLMInvoker as D
 from gllm_inference.lm_invoker.google_lm_invoker import GoogleLMInvoker as GoogleLMInvoker
 from gllm_inference.lm_invoker.langchain_lm_invoker import LangChainLMInvoker as LangChainLMInvoker
 from gllm_inference.lm_invoker.litellm_lm_invoker import LiteLLMLMInvoker as LiteLLMLMInvoker
+from gllm_inference.lm_invoker.openai_chat_completions_lm_invoker import OpenAIChatCompletionsLMInvoker as OpenAIChatCompletionsLMInvoker
 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', 'XAILMInvoker']
+__all__ = ['AnthropicLMInvoker', 'AzureOpenAILMInvoker', 'BedrockLMInvoker', 'DatasaurLMInvoker', 'GoogleLMInvoker', 'LangChainLMInvoker', 'LiteLLMLMInvoker', 'OpenAIChatCompletionsLMInvoker', 'OpenAICompatibleLMInvoker', 'OpenAILMInvoker', 'XAILMInvoker']

gllm_inference/lm_invoker/langchain_lm_invoker.pyi

@@ -37,7 +37,7 @@ class LangChainLMInvoker(BaseLMInvoker):
         ```python
         lm_invoker = LangChainLMInvoker(
             model_class_path="langchain_openai.ChatOpenAI",
-            model_name="gpt-4.1-nano",
+            model_name="gpt-5-nano",
         )
         result = await lm_invoker.invoke("Hi there!")
         ```
@@ -50,7 +50,7 @@ class LangChainLMInvoker(BaseLMInvoker):
         ```python
         from langchain_openai import ChatOpenAI
 
-        model = ChatOpenAI(model="gpt-4.1-nano", api_key="your_api_key")
+        model = ChatOpenAI(model="gpt-5-nano", api_key="your_api_key")
         lm_invoker = LangChainLMInvoker(model=model)
         ```
 
@@ -59,7 +59,7 @@ class LangChainLMInvoker(BaseLMInvoker):
         ```python
         lm_invoker = LangChainLMInvoker(
             model_class_path="langchain_openai.ChatOpenAI",
-            model_name="gpt-4.1-nano",
+            model_name="gpt-5-nano",
             model_kwargs={"api_key": "your_api_key"}
         )
         ```

gllm_inference/lm_invoker/litellm_lm_invoker.pyi

@@ -27,7 +27,7 @@ class LiteLLMLMInvoker(OpenAICompatibleLMInvoker):
     Basic usage:
         The `LiteLLMLMInvoker` can be used as follows:
         ```python
-        lm_invoker = LiteLLMLMInvoker(model_id="openai/gpt-4.1-nano")
+        lm_invoker = LiteLLMLMInvoker(model_id="openai/gpt-5-nano")
         result = await lm_invoker.invoke("Hi there!")
         ```
 

gllm_inference/lm_invoker/openai_chat_completions_lm_invoker.pyi

@@ -0,0 +1,278 @@
+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 INVOKER_PROPAGATED_MAX_RETRIES as INVOKER_PROPAGATED_MAX_RETRIES, OPENAI_DEFAULT_URL as OPENAI_DEFAULT_URL
+from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker as BaseLMInvoker
+from gllm_inference.lm_invoker.schema.openai_chat_completions import InputType as InputType, 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 import validate_string_enum as validate_string_enum
+from langchain_core.tools import Tool as LangChainTool
+from typing import Any
+
+SUPPORTED_ATTACHMENTS: Incomplete
+
+class OpenAIChatCompletionsLMInvoker(BaseLMInvoker):
+    '''A language model invoker to interact with OpenAI language models using the Chat Completions API.
+
+    This class provides support for OpenAI\'s Chat Completions API schema. Use this class only when you have
+    a specific reason to use the Chat Completions API over the Responses API, as OpenAI recommends using
+    the Responses API whenever possible. The Responses API schema is supported through the `OpenAILMInvoker` class.
+
+    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 (AsyncOpenAI): The OpenAI client instance.
+        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.
+
+    Basic usage:
+        The `OpenAIChatCompletionsLMInvoker` can be used as follows:
+        ```python
+        lm_invoker = OpenAIChatCompletionsLMInvoker(model_name="gpt-5-nano")
+        result = await lm_invoker.invoke("Hi there!")
+        ```
+
+    OpenAI compatible endpoints:
+        The `OpenAIChatCompletionsLMInvoker` can also be used to interact with endpoints that are compatible with
+        OpenAI\'s Chat Completions API schema. This includes but are not limited to:
+        1. DeepInfra (https://deepinfra.com/)
+        2. DeepSeek (https://deepseek.com/)
+        3. Groq (https://groq.com/)
+        4. OpenRouter (https://openrouter.ai/)
+        5. Text Generation Inference (https://github.com/huggingface/text-generation-inference)
+        6. Together.ai (https://together.ai/)
+        7. vLLM (https://vllm.ai/)
+        Please note that the supported features and capabilities may vary between different endpoints and
+        language models. Using features that are not supported by the endpoint will result in an error.
+
+        This customization can be done by setting the `base_url` parameter to the base URL of the endpoint:
+        ```python
+        lm_invoker = OpenAIChatCompletionsLMInvoker(
+            model_name="llama3-8b-8192",
+            api_key="<your-api-key>",
+            base_url="https://api.groq.com/openai/v1",
+        )
+        result = await lm_invoker.invoke("Hi there!")
+        ```
+
+    Input types:
+        The `OpenAIChatCompletionsLMInvoker` supports the following input types: text, audio, document, 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 = OpenAIChatCompletionsLMInvoker(..., 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 = OpenAIChatCompletionsLMInvoker(..., 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 = OpenAIChatCompletionsLMInvoker(..., response_schema=Animal)
+        ```
+        Output example:
+        ```python
+        LMOutput(structured_output=Animal(name="Golden retriever", color="Golden"))
+        ```
+
+    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. `duration`: The duration in seconds.
+        3. `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),
+            duration=0.729,
+            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 `OpenAIChatCompletionsLMInvoker` 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 = OpenAIChatCompletionsLMInvoker(..., retry_config=retry_config)
+        ```
+
+    Reasoning:
+        Some language models support advanced reasoning capabilities. When using such reasoning-capable models,
+        you can configure how much reasoning the model should perform before generating a final response by setting
+        reasoning-related parameters.
+
+        The reasoning effort of reasoning models can be set via the `reasoning_effort` parameter. This parameter
+        will guide the models on how many reasoning tokens it should generate before creating a response to the prompt.
+        The reasoning effort is only supported by some language models.
+        Available options include:
+        1. "low": Favors speed and economical token usage.
+        2. "medium": Favors a balance between speed and reasoning accuracy.
+        3. "high": Favors more complete reasoning at the cost of more tokens generated and slower responses.
+        This may differ between models. When not set, the reasoning effort will be equivalent to None by default.
+
+        When using reasoning models, some providers might output the reasoning summary. These will be stored in the
+        `reasoning` attribute in the output.
+
+        Output example:
+        ```python
+        LMOutput(
+            response="Golden retriever is a good dog breed.",
+            reasoning=[Reasoning(id="", reasoning="Let me think about it...")],
+        )
+        ```
+
+        When streaming is enabled along with reasoning and the provider supports reasoning output, the reasoning 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.
+
+    Output types:
+        The output of the `OpenAIChatCompletionsLMInvoker` 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. Currently not supported. Defaults to an empty list.
+            2.8. citations (list[Chunk]): The citations. Currently not supported. Defaults to an empty list.
+            2.9. code_exec_results (list[CodeExecResult]): The code execution results. Currently not supported.
+                Defaults to an empty list.
+            2.10. mcp_calls (list[MCPCall]): The MCP calls. Currently not supported. Defaults to an empty list.
+    '''
+    client: Incomplete
+    def __init__(self, model_name: str, api_key: str | None = None, base_url: str = ..., 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) -> None:
+        '''Initializes a new instance of the OpenAIChatCompletionsLMInvoker class.
+
+        Args:
+            model_name (str): The name of the OpenAI model.
+            api_key (str | None, optional): The API key for authenticating with OpenAI. Defaults to None, in which
+                case the `OPENAI_API_KEY` environment variable will be used. If the endpoint does not require an
+                API key, a dummy value can be passed (e.g. "<empty>").
+            base_url (str, optional): The base URL of a custom endpoint that is compatible with OpenAI\'s
+                Chat Completions API schema. Defaults to OpenAI\'s default URL.
+            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 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 will be used.
+            reasoning_effort (str | None, optional): The reasoning effort for the language model. Defaults to None.
+        '''
+    def set_response_schema(self, response_schema: ResponseSchema | None) -> None:
+        """Sets the response schema for the OpenAI language model.
+
+        This method sets the response schema for the OpenAI language model.
+        Any existing response schema will be replaced.
+
+        Args:
+            response_schema (ResponseSchema | None): The response schema to be used.
+        """

gllm_inference/lm_invoker/openai_compatible_lm_invoker.pyi

@@ -1,19 +1,15 @@
-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 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.openai_compatible import InputType as InputType, 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 import validate_string_enum as validate_string_enum
+from gllm_core.utils import RetryConfig as RetryConfig
+from gllm_inference.lm_invoker.openai_chat_completions_lm_invoker import OpenAIChatCompletionsLMInvoker as OpenAIChatCompletionsLMInvoker
+from gllm_inference.lm_invoker.schema.openai_chat_completions import ReasoningEffort as ReasoningEffort
+from gllm_inference.schema import ResponseSchema as ResponseSchema
 from langchain_core.tools import Tool as LangChainTool
 from typing import Any
 
-SUPPORTED_ATTACHMENTS: Incomplete
+DEPRECATION_MESSAGE: str
 
-class OpenAICompatibleLMInvoker(BaseLMInvoker):
-    '''A language model invoker to interact with endpoints compatible with OpenAI\'s chat completion API contract.
+class OpenAICompatibleLMInvoker(OpenAIChatCompletionsLMInvoker):
+    """A language model invoker to interact with endpoints compatible with OpenAI's chat completion API contract.
 
     Attributes:
         model_id (str): The model ID of the language model.
@@ -27,212 +23,8 @@ class OpenAICompatibleLMInvoker(BaseLMInvoker):
         output_analytics (bool): Whether to output the invocation analytics.
         retry_config (RetryConfig | None): The retry configuration for the language model.
 
-    When to use:
-        The `OpenAICompatibleLMInvoker` is designed to interact with endpoints that are compatible with OpenAI\'s chat
-        completion API contract. This includes but are not limited to:
-        1. DeepInfra (https://deepinfra.com/)
-        2. DeepSeek (https://deepseek.com/)
-        3. Groq (https://groq.com/)
-        4. OpenRouter (https://openrouter.ai/)
-        5. Text Generation Inference (https://github.com/huggingface/text-generation-inference)
-        6. Together.ai (https://together.ai/)
-        7. vLLM (https://vllm.ai/)
-        When using this invoker, please note that the supported features and capabilities may vary between different
-        endpoints and language models. Using features that are not supported by the endpoint will result in an error.
-
-    Basic usage:
-        The `OpenAICompatibleLMInvoker` can be used as follows:
-        ```python
-        lm_invoker = OpenAICompatibleLMInvoker(
-            model_name="llama3-8b-8192",
-            base_url="https://api.groq.com/openai/v1",
-            api_key="<your-api-key>"
-        )
-        result = await lm_invoker.invoke("Hi there!")
-        ```
-
-    Input types:
-        The `OpenAICompatibleLMInvoker` supports the following input types: text, audio, document, 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 = OpenAICompatibleLMInvoker(..., 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 = OpenAICompatibleLMInvoker(..., 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 = OpenAICompatibleLMInvoker(..., response_schema=Animal)
-        ```
-        Output example:
-        ```python
-        LMOutput(structured_output=Animal(name="Golden retriever", color="Golden"))
-        ```
-
-    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. `duration`: The duration in seconds.
-        3. `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),
-            duration=0.729,
-            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 `OpenAICompatibleLMInvoker` 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 = OpenAICompatibleLMInvoker(..., retry_config=retry_config)
-        ```
-
-    Reasoning:
-        Some language models support advanced reasoning capabilities. When using such reasoning-capable models,
-        you can configure how much reasoning the model should perform before generating a final response by setting
-        reasoning-related parameters.
-
-        The reasoning effort of reasoning models can be set via the `reasoning_effort` parameter. This parameter
-        will guide the models on how many reasoning tokens it should generate before creating a response to the prompt.
-        The reasoning effort is only supported by some language models.
-        Available options include:
-        1. "low": Favors speed and economical token usage.
-        2. "medium": Favors a balance between speed and reasoning accuracy.
-        3. "high": Favors more complete reasoning at the cost of more tokens generated and slower responses.
-        This may differ between models. When not set, the reasoning effort will be equivalent to None by default.
-
-        When using reasoning models, some providers might output the reasoning summary. These will be stored in the
-        `reasoning` attribute in the output.
-
-        Output example:
-        ```python
-        LMOutput(
-            response="Golden retriever is a good dog breed.",
-            reasoning=[Reasoning(id="", reasoning="Let me think about it...")],
-        )
-        ```
-
-        When streaming is enabled along with reasoning and the provider supports reasoning output, the reasoning 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.
-
-    Output types:
-        The output of the `OpenAICompatibleLMInvoker` 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. Currently not supported. Defaults to an empty list.
-            2.8. citations (list[Chunk]): The citations. Currently not supported. Defaults to an empty list.
-            2.9. code_exec_results (list[CodeExecResult]): The code execution results. Currently not supported.
-                Defaults to an empty list.
-            2.10. mcp_calls (list[MCPCall]): The MCP calls. Currently not supported. Defaults to an empty list.
-    '''
-    client: Incomplete
+    This class is deprecated and will be removed in v0.6. Please use the `OpenAIChatCompletionsLMInvoker` class instead.
+    """
     def __init__(self, model_name: str, base_url: 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) -> None:
         '''Initializes a new instance of the OpenAICompatibleLMInvoker class.
 
@@ -255,12 +47,3 @@ class OpenAICompatibleLMInvoker(BaseLMInvoker):
                 Defaults to None, in which case a default config with no retry and 30.0 seconds timeout will be used.
             reasoning_effort (str | None, optional): The reasoning effort for the language model. Defaults to None.
         '''
-    def set_response_schema(self, response_schema: ResponseSchema | None) -> None:
-        """Sets the response schema for the language model hosted on the OpenAI compatible endpoint.
-
-        This method sets the response schema for the language model hosted on the OpenAI compatible endpoint. Any
-        existing response schema will be replaced.
-
-        Args:
-            response_schema (ResponseSchema | None): The response schema to be used.
-        """

gllm_inference/lm_invoker/openai_lm_invoker.pyi

@@ -2,7 +2,7 @@ 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 INVOKER_PROPAGATED_MAX_RETRIES as INVOKER_PROPAGATED_MAX_RETRIES
+from gllm_inference.constants import INVOKER_PROPAGATED_MAX_RETRIES as INVOKER_PROPAGATED_MAX_RETRIES, OPENAI_DEFAULT_URL as OPENAI_DEFAULT_URL
 from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker as BaseLMInvoker
 from gllm_inference.lm_invoker.schema.openai import InputType as InputType, Key as Key, OutputType as OutputType, ReasoningEffort as ReasoningEffort, ReasoningSummary as ReasoningSummary
 from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, CodeExecResult as CodeExecResult, EmitDataType as EmitDataType, LMOutput as LMOutput, MCPCall as MCPCall, MCPServer as MCPServer, 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
@@ -17,6 +17,10 @@ STREAM_DATA_CONTENT_TYPE_MAP: Incomplete
 class OpenAILMInvoker(BaseLMInvoker):
     '''A language model invoker to interact with OpenAI language models.
 
+    This class provides support for OpenAI\'s Responses API schema, which is recommended by OpenAI as the preferred API
+    to use whenever possible. Use this class unless you have a specific reason to use the Chat Completions API instead.
+    The Chat Completions API schema is supported through the `OpenAIChatCompletionsLMInvoker` class.
+
     Attributes:
         model_id (str): The model ID of the language model.
         model_provider (str): The provider of the language model.
@@ -39,7 +43,24 @@ class OpenAILMInvoker(BaseLMInvoker):
     Basic usage:
         The `OpenAILMInvoker` can be used as follows:
         ```python
-        lm_invoker = OpenAILMInvoker(model_name="gpt-4.1-nano")
+        lm_invoker = OpenAILMInvoker(model_name="gpt-5-nano")
+        result = await lm_invoker.invoke("Hi there!")
+        ```
+
+    OpenAI compatible endpoints:
+        The `OpenAILMInvoker` can also be used to interact with endpoints that are compatible with
+        OpenAI\'s Responses API schema. This includes but are not limited to:
+        1. SGLang (https://github.com/sgl-project/sglang)
+        Please note that the supported features and capabilities may vary between different endpoints and
+        language models. Using features that are not supported by the endpoint will result in an error.
+
+        This customization can be done by setting the `base_url` parameter to the base URL of the endpoint:
+        ```python
+        lm_invoker = OpenAILMInvoker(
+            model_name="<model-name>",
+            api_key="<your-api-key>",
+            base_url="<https://base-url>",
+        )
         result = await lm_invoker.invoke("Hi there!")
         ```
 
@@ -371,13 +392,16 @@ class OpenAILMInvoker(BaseLMInvoker):
                 decides to invoke MCP tools. Defaults to an empty list.
     '''
     client: 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, reasoning_summary: ReasoningSummary | None = None, mcp_servers: list[MCPServer] | None = None, code_interpreter: bool = False, web_search: bool = False) -> None:
-        """Initializes a new instance of the OpenAILMInvoker class.
+    def __init__(self, model_name: str, api_key: str | None = None, base_url: str = ..., 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, reasoning_summary: ReasoningSummary | None = None, mcp_servers: list[MCPServer] | None = None, code_interpreter: bool = False, web_search: bool = False) -> None:
+        '''Initializes a new instance of the OpenAILMInvoker class.
 
         Args:
             model_name (str): The name of the OpenAI model.
             api_key (str | None, optional): The API key for authenticating with OpenAI. Defaults to None, in which
-                case the `OPENAI_API_KEY` environment variable will be used.
+                case the `OPENAI_API_KEY` environment variable will be used. If the endpoint does not require an
+                API key, a dummy value can be passed (e.g. "<empty>").
+            base_url (str, optional): The base URL of a custom endpoint that is compatible with OpenAI\'s
+                Responses API schema. Defaults to OpenAI\'s default URL.
             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.
@@ -402,7 +426,7 @@ class OpenAILMInvoker(BaseLMInvoker):
             ValueError:
             1. `reasoning_effort` is provided, but is not a valid ReasoningEffort.
             2. `reasoning_summary` is provided, but is not a valid ReasoningSummary.
-        """
+        '''
     def set_response_schema(self, response_schema: ResponseSchema | None) -> None:
         """Sets the response schema for the OpenAI language model.
 

gllm_inference/lm_invoker/schema/{openai_compatible.pyi → openai_chat_completions.pyi}

@@ -1,7 +1,7 @@
 from enum import StrEnum
 
 class Key:
-    """Defines valid keys in OpenAI compatible models."""
+    """Defines valid keys in OpenAI Chat Completions."""
     ARGUMENTS: str
     CONTENT: str
     CHOICES: str
@@ -42,7 +42,7 @@ class Key:
     SUMMARY: str
 
 class InputType:
-    """Defines valid input types in OpenAI compatible models."""
+    """Defines valid input types in OpenAI Chat Completions."""
     FILE: str
     FUNCTION: str
     IMAGE_URL: str

gllm_inference/schema/model_id.pyi

@@ -1,3 +1,4 @@
+from _typeshed import Incomplete
 from enum import StrEnum
 from gllm_inference.utils import validate_string_enum as validate_string_enum
 from pydantic import BaseModel
@@ -16,11 +17,15 @@ class ModelProvider(StrEnum):
     LANGCHAIN = 'langchain'
     LITELLM = 'litellm'
     OPENAI = 'openai'
+    OPENAI_CHAT_COMPLETIONS = 'openai-chat-completions'
     OPENAI_COMPATIBLE = 'openai-compatible'
     TWELVELABS = 'twelvelabs'
     VOYAGE = 'voyage'
     XAI = 'xai'
 
+OPTIONAL_PATH_PROVIDERS: Incomplete
+PATH_SUPPORTING_PROVIDERS: Incomplete
+
 class ModelId(BaseModel):
     '''Defines a representation of a valid model id.
 
@@ -32,7 +37,7 @@ class ModelId(BaseModel):
     Provider-specific examples:
         # Using Anthropic
         ```python
-        model_id = ModelId.from_string("anthropic/claude-3-5-sonnet-latest")
+        model_id = ModelId.from_string("anthropic/claude-sonnet-4-20250514")
         ```
 
         # Using Bedrock
@@ -47,22 +52,32 @@ class ModelId(BaseModel):
 
         # Using Google
         ```python
-        model_id = ModelId.from_string("google/gemini-1.5-flash")
+        model_id = ModelId.from_string("google/gemini-2.5-flash-lite")
         ```
 
         # Using OpenAI
         ```python
-        model_id = ModelId.from_string("openai/gpt-4o-mini")
+        model_id = ModelId.from_string("openai/gpt-5-nano")
         ```
 
-        # Using Azure OpenAI
+        # Using OpenAI with Chat Completions API
         ```python
-        model_id = ModelId.from_string("azure-openai/https://my-resource.openai.azure.com/openai/v1:my-deployment")
+        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 compatible endpoints (e.g. Groq)
+        # Using OpenAI Chat Completions API-compatible endpoints (e.g. Groq)
         ```python
-        model_id = ModelId.from_string("openai-compatible/https://api.groq.com/openai/v1:llama3-8b-8192")
+        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
@@ -89,7 +104,7 @@ class ModelId(BaseModel):
         For the list of supported providers, please refer to the following page:
         https://docs.litellm.ai/docs/providers/
 
-        # Using XAI
+        # Using xAI
         ```python
         model_id = ModelId.from_string("xai/grok-4-0709")
         ```
@@ -99,9 +114,9 @@ class ModelId(BaseModel):
     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"},
+            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)
@@ -115,13 +130,8 @@ class ModelId(BaseModel):
         """Parse a model id string into a ModelId object.
 
         Args:
-            model_id (str): The model id to parse. Must be in the the following format:
-                1. For `azure-openai` provider: `azure-openai/azure-endpoint:azure-deployment`.
-                2. For `openai-compatible` provider: `openai-compatible/base-url:model-name`.
-                3. For `langchain` provider: `langchain/<package>.<class>:model-name`.
-                4. For `litellm` provider: `litellm/provider/model-name`.
-                5. For `datasaur` provider: `datasaur/base-url`.
-                6. For other providers: `provider/model-name`.
+            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.
@@ -137,11 +147,6 @@ class ModelId(BaseModel):
         """Convert the ModelId object to a string.
 
         Returns:
-            str: The string representation of the ModelId object. The format is as follows:
-                1. For `azure-openai` provider: `azure-openai/azure-endpoint:azure-deployment`.
-                2. For `openai-compatible` provider: `openai-compatible/base-url:model-name`.
-                3. For `langchain` provider: `langchain/<package>.<class>:model-name`.
-                4. For `litellm` provider: `litellm/provider/model-name`.
-                5. For `datasaur` provider: `datasaur/base-url`.
-                6. For other providers: `provider/model-name`.
+            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.pyi

@@ -27,6 +27,7 @@ import gllm_inference.lm_invoker.DatasaurLMInvoker
 import gllm_inference.lm_invoker.GoogleLMInvoker
 import gllm_inference.lm_invoker.LangChainLMInvoker
 import gllm_inference.lm_invoker.LiteLLMLMInvoker
+import gllm_inference.lm_invoker.OpenAIChatCompletionsLMInvoker
 import gllm_inference.lm_invoker.OpenAICompatibleLMInvoker
 import gllm_inference.lm_invoker.OpenAILMInvoker
 import gllm_inference.lm_invoker.XAILMInvoker

{gllm_inference_binary-0.5.34.dist-info → gllm_inference_binary-0.5.35.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: gllm-inference-binary
-Version: 0.5.34
+Version: 0.5.35
 Summary: A library containing components related to model inferences in Gen AI applications.
 Author-email: Henry Wicaksono <henry.wicaksono@gdplabs.id>, Resti Febrina <resti.febrina@gdplabs.id>
 Requires-Python: <3.14,>=3.11

{gllm_inference_binary-0.5.34.dist-info → gllm_inference_binary-0.5.35.dist-info}/RECORD

@@ -1,15 +1,15 @@
-gllm_inference.cp311-win_amd64.pyd,sha256=5hvgBNRlmrNo8Co2DmMPfAmNF2SIOgoo1AXSsFntwLs,3229184
-gllm_inference.pyi,sha256=bvMQNMzysfZtXgjW4ZX0KwSOV4uroNakpE0NUHKCMmk,4199
+gllm_inference.cp311-win_amd64.pyd,sha256=iLhp_OTfO7KR3_ifQCN3KIni-vQaL_3nlldp6oJ0vYU,3258368
+gllm_inference.pyi,sha256=bOGYhW7SnMMPCLRRlkVbSq8I8xn8YwHssI1zZoD1lVU,4263
 gllm_inference/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gllm_inference/constants.pyi,sha256=KQmondDEkHK2P249ymmce3SdutVrx8kYm4v1eTCkW9U,277
+gllm_inference/constants.pyi,sha256=1OBoHfeWfW9bXH9kStNEH__MGnGp--jLfyheAeQnogY,302
 gllm_inference/builder/__init__.pyi,sha256=-bw1uDx7CAM7pkvjvb1ZXku9zXlQ7aEAyC83KIn3bz8,506
-gllm_inference/builder/build_em_invoker.pyi,sha256=Mh1vRoJhsqc8hX4jUdopV14Fn44ql27NB7xbGjoHJtE,6020
-gllm_inference/builder/build_lm_invoker.pyi,sha256=p63iuVBOOpNizItGK6HDxYDrgXdovtfSe0VrvrEd-PA,7047
-gllm_inference/builder/build_lm_request_processor.pyi,sha256=0pJINCP4nnXVwuhIbhsaiwzjX8gohQt2oqXFZhTFSUs,4584
+gllm_inference/builder/build_em_invoker.pyi,sha256=r4p0T9g_831Fq0youhxdMrQMWkzARw-PSahMu83ZzQo,5762
+gllm_inference/builder/build_lm_invoker.pyi,sha256=HvQICF-qvOTzfXZUqhi7rlwcpkMZpxaC-8QZmhnXKzI,7466
+gllm_inference/builder/build_lm_request_processor.pyi,sha256=H7Rg88e7PTTCtuyY64r333moTmh4-ypOwgnG10gkEdY,4232
 gllm_inference/builder/build_output_parser.pyi,sha256=sgSTrzUmSRxPzUUum0fDU7A3NXYoYhpi6bEx4Q2XMnA,965
 gllm_inference/catalog/__init__.pyi,sha256=HWgPKWIzprpMHRKe_qN9BZSIQhVhrqiyjLjIXwvj1ho,291
 gllm_inference/catalog/catalog.pyi,sha256=eWPqgQKi-SJGHabi_XOTEKpAj96OSRypKsb5ZEC1VWU,4911
-gllm_inference/catalog/lm_request_processor_catalog.pyi,sha256=GemCEjFRHNChtNOfbyXSVsJiA3klOCAe_X11fnymhYs,5540
+gllm_inference/catalog/lm_request_processor_catalog.pyi,sha256=FiveqPDkV58XbDO2znXL-Ix5tFbZwNiVnitlEa90YOY,5536
 gllm_inference/catalog/prompt_builder_catalog.pyi,sha256=iViWB4SaezzjQY4UY1YxeoXUNxqxa2cTJGaD9JSx4Q8,3279
 gllm_inference/em_invoker/__init__.pyi,sha256=pmbsjmsqXwfe4WPykMnrmasKrYuylJWnf2s0pbo0ioM,997
 gllm_inference/em_invoker/azure_openai_em_invoker.pyi,sha256=SfJPC_PJGiEfWS9JH5kRQPJztsR7jRhwVuETqdY-JsQ,5021
@@ -17,8 +17,8 @@ gllm_inference/em_invoker/bedrock_em_invoker.pyi,sha256=UqodtpDmE7fEgpctXEETIlZG
 gllm_inference/em_invoker/em_invoker.pyi,sha256=YDYJ8TGScsz5Gg-OBnEENN1tI1RYvwoddypxUr6SAWw,5191
 gllm_inference/em_invoker/google_em_invoker.pyi,sha256=q69kdVuE44ZqziQ8BajFYZ1tYn-MPjKjzXS9cRh4oAo,6951
 gllm_inference/em_invoker/langchain_em_invoker.pyi,sha256=nhX6LynrjhfySEt_44OlLoSBd15hoz3giWyNM9CYLKY,3544
-gllm_inference/em_invoker/openai_compatible_em_invoker.pyi,sha256=zEYOBDXKQhvcMGer9DYDu50_3KRDjYyN8-JgpBIFPOI,5456
-gllm_inference/em_invoker/openai_em_invoker.pyi,sha256=0TDIQa-5UwsPcVxgkze-QJJWrt-ToakAKbuAk9TW5SM,4746
+gllm_inference/em_invoker/openai_compatible_em_invoker.pyi,sha256=S7OHYa1VF24tiv46VCjHN3zZtHDNr5XT_k1acti54jY,2889
+gllm_inference/em_invoker/openai_em_invoker.pyi,sha256=jqsj9rlNW13XSkDUpNwSIUhiQcc8U1Py7hHQ1FZS5CM,6280
 gllm_inference/em_invoker/twelevelabs_em_invoker.pyi,sha256=MMVgSnjMXksdhSDXIi3vOULIXnjbhtq19eR5LPnUmGo,5446
 gllm_inference/em_invoker/voyage_em_invoker.pyi,sha256=vdB_qS8QKrCcb-HtXwKZS4WW1R1wGzpMBFmOKC39sjU,5619
 gllm_inference/em_invoker/langchain/__init__.pyi,sha256=aOTlRvS9aG1tBErjsmhe75s4Sq-g2z9ArfGqNW7QyEs,151
@@ -35,17 +35,18 @@ gllm_inference/exceptions/__init__.pyi,sha256=nXOqwsuwUgsnBcJEANVuxbZ1nDfcJ6-pKU
 gllm_inference/exceptions/error_parser.pyi,sha256=4aiJZhBzBOqlhdmpvaCvildGy7_XxlJzQpe3PzGt8eE,2040
 gllm_inference/exceptions/exceptions.pyi,sha256=6y3ECgHAStqMGgQv8Dv-Ui-5PDD07mSj6qaRZeSWea4,5857
 gllm_inference/exceptions/provider_error_map.pyi,sha256=4AsAgbXAh91mxEW2YiomEuhBoeSNeAIo9WbT9WK8gQk,1233
-gllm_inference/lm_invoker/__init__.pyi,sha256=eE_HDCl9A135mi6mtIV55q-T9J1O8OpbMcqWuny3w9A,1214
+gllm_inference/lm_invoker/__init__.pyi,sha256=jG1xc5fTOeIgeKKVYSnsMzQThKk9kTW38yO_MYtv540,1387
 gllm_inference/lm_invoker/anthropic_lm_invoker.pyi,sha256=5fscLpROscxjBNP13GmcU9I83YiZH-pb42FzQ2JzGBA,17575
 gllm_inference/lm_invoker/azure_openai_lm_invoker.pyi,sha256=Tcmr0OfEk3As4nmL_lCoQzVB9qTQ2BLASRFhcObvrPY,15286
 gllm_inference/lm_invoker/bedrock_lm_invoker.pyi,sha256=ptyHTm1szPJEpQObdrsxHpbTkchCWE6K-YmVTmbdhvM,13037
 gllm_inference/lm_invoker/datasaur_lm_invoker.pyi,sha256=sR1vSTifBykASzAGMYn7nJVxTEwXMFz-Xa0rQjXzb6A,9482
 gllm_inference/lm_invoker/google_lm_invoker.pyi,sha256=Zkt-BdOZT106mn07_7krBQ5GiXsp9z9aoHs_d96P4lg,17482
-gllm_inference/lm_invoker/langchain_lm_invoker.pyi,sha256=2pghfayLQxNJ1UEJZGPCro_sfFq0u4_RFSupcSsNkg8,13972
-gllm_inference/lm_invoker/litellm_lm_invoker.pyi,sha256=7OJSwv0FCg9Hf4wxtdHcblCcFYu4SqPiMACFH-ZM1c0,13489
+gllm_inference/lm_invoker/langchain_lm_invoker.pyi,sha256=dKN0flBxjiCUWW1QOz8HjoRfKpqXjNEz1pm5cS-40zA,13966
+gllm_inference/lm_invoker/litellm_lm_invoker.pyi,sha256=cnkg4Lk9sRqXylWQq5G3ujD_DzcVX88DCfEpA5hkTFA,13487
 gllm_inference/lm_invoker/lm_invoker.pyi,sha256=JQFExiblFbCMQ3HXOE62Ho1VTMdmxf_CZ-edGSQbCrQ,8312
-gllm_inference/lm_invoker/openai_compatible_lm_invoker.pyi,sha256=7Tnq-4Cl46sPDLiRQLQBDFuk_INhm0BIknXZXqXYb-8,15316
-gllm_inference/lm_invoker/openai_lm_invoker.pyi,sha256=NK-HJXvRrQjDgfpqXGUBi_rf5iTiMjJvxfRsqj_JT_I,22512
+gllm_inference/lm_invoker/openai_chat_completions_lm_invoker.pyi,sha256=9Nkun_k_i1VDx3A0ixOosAYp_8WpfzjW-UBI-T_3g6M,16014
+gllm_inference/lm_invoker/openai_compatible_lm_invoker.pyi,sha256=HkHIDtuw1IIwDglOelAy6VKwKmslEVTOsgC1Ememsq0,3886
+gllm_inference/lm_invoker/openai_lm_invoker.pyi,sha256=GPzPZeKiopSk0zLydQY0bQ3V3-oka9BNtFCepdYiEl4,24065
 gllm_inference/lm_invoker/xai_lm_invoker.pyi,sha256=6TwO3KU1DBWoe4UAsz97MY1yKBf-N38WjbrBqCmWCNU,15992
 gllm_inference/lm_invoker/batch/__init__.pyi,sha256=vJOTHRJ83oq8Bq0UsMdID9_HW5JAxr06gUs4aPRZfEE,130
 gllm_inference/lm_invoker/batch/batch_operations.pyi,sha256=o2U17M41RKVFW6j_oxy-SxU1JqUtVt75pKRxrqXzorE,5499
@@ -56,7 +57,7 @@ gllm_inference/lm_invoker/schema/datasaur.pyi,sha256=GLv6XAwKtWyRrX6EsbEufYjkPff
 gllm_inference/lm_invoker/schema/google.pyi,sha256=elXHrUMS46pbTsulk7hBXVVFcT022iD-_U_I590xeV8,529
 gllm_inference/lm_invoker/schema/langchain.pyi,sha256=2OJOUQPlGdlUbIOTDOyiWDBOMm3MoVX-kU2nK0zQsF0,452
 gllm_inference/lm_invoker/schema/openai.pyi,sha256=eDbU3lGOeJgwuaEVv2Zd0amylGX4e-d78_97kPN1cuQ,2291
-gllm_inference/lm_invoker/schema/openai_compatible.pyi,sha256=fVLRIrOvLJjhY7qPUgC3HRFoOFa7XimWLjr2EOo5qmQ,1226
+gllm_inference/lm_invoker/schema/openai_chat_completions.pyi,sha256=8oYQ2VC7L4WQpBAdUEDNIJKvcSGEdu4z_iIuy_TQpeE,1224
 gllm_inference/lm_invoker/schema/xai.pyi,sha256=jpC6ZSBDUltzm9GjD6zvSFIPwqizn_ywLnjvwSa7KuU,663
 gllm_inference/model/__init__.pyi,sha256=JKQB0wVSVYD-_tdRkG7N_oEVAKGCcoBw0BUOUMLieFo,602
 gllm_inference/model/em/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -94,7 +95,7 @@ gllm_inference/schema/lm_input.pyi,sha256=HxQiZgY7zcXh_Dw8nK8LSeBTZEHMPZVwmPmnfg
 gllm_inference/schema/lm_output.pyi,sha256=xafvq38SJkon0QfkuhswCX8ql777el5dUmzbbhLyOvA,2222
 gllm_inference/schema/mcp.pyi,sha256=4SgQ83pEowfWm2p-w9lupV4NayqqVBOy7SuYxIFeWRs,1045
 gllm_inference/schema/message.pyi,sha256=jJV6A0ihEcun2OhzyMtNkiHnf7d6v5R-GdpTBGfJ0AQ,2272
-gllm_inference/schema/model_id.pyi,sha256=h2nAmYgUYjF8MjT9pTnRfrevYuSHeksEZHvizkmu6n8,5638
+gllm_inference/schema/model_id.pyi,sha256=NuaS4XlKDRJJezj45CEzn8reDDeII9XeRARmM5SZPqA,5408
 gllm_inference/schema/reasoning.pyi,sha256=jbPxkDRHt0Vt-zdcc8lTT1l2hIE1Jm3HIHeNd0hfXGo,577
 gllm_inference/schema/token_usage.pyi,sha256=WJiGQyz5qatzBK2b-sABLCyTRLCBbAvxCRcqSJOzu-8,3025
 gllm_inference/schema/tool_call.pyi,sha256=OWT9LUqs_xfUcOkPG0aokAAqzLYYDkfnjTa0zOWvugk,403
@@ -105,7 +106,7 @@ gllm_inference/utils/io_utils.pyi,sha256=Eg7dvHWdXslTKdjh1j3dG50i7r35XG2zTmJ9XXv
 gllm_inference/utils/langchain.pyi,sha256=4AwFiVAO0ZpdgmqeC4Pb5NJwBt8vVr0MSUqLeCdTscc,1194
 gllm_inference/utils/validation.pyi,sha256=-RdMmb8afH7F7q4Ao7x6FbwaDfxUHn3hA3WiOgzB-3s,397
 gllm_inference.build/.gitignore,sha256=aEiIwOuxfzdCmLZe4oB1JsBmCUxwG8x-u-HBCV9JT8E,1
-gllm_inference_binary-0.5.34.dist-info/METADATA,sha256=25f0Qk4Wr-hCBMFbHGd2lF1tRqSDdtQIjhIqKw-ds28,5770
-gllm_inference_binary-0.5.34.dist-info/WHEEL,sha256=l2aKBREYfqJ7T2ljmr6hUiXPoNvvXF47bG4IHjuSyS4,96
-gllm_inference_binary-0.5.34.dist-info/top_level.txt,sha256=FpOjtN80F-qVNgbScXSEyqa0w09FYn6301iq6qt69IQ,15
-gllm_inference_binary-0.5.34.dist-info/RECORD,,
+gllm_inference_binary-0.5.35.dist-info/METADATA,sha256=8BM_m-hKxOYbudW-KKFBmrwJOXeMrWKzueq-EZ_KIGo,5770
+gllm_inference_binary-0.5.35.dist-info/WHEEL,sha256=l2aKBREYfqJ7T2ljmr6hUiXPoNvvXF47bG4IHjuSyS4,96
+gllm_inference_binary-0.5.35.dist-info/top_level.txt,sha256=FpOjtN80F-qVNgbScXSEyqa0w09FYn6301iq6qt69IQ,15
+gllm_inference_binary-0.5.35.dist-info/RECORD,,