gllm-inference-binary 0.5.33__cp312-cp312-macosx_13_0_x86_64.whl → 0.5.35__cp312-cp312-macosx_13_0_x86_64.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!")
         ```