gllm-inference-binary 0.5.44__cp313-cp313-win_amd64.whl → 0.5.46__cp313-cp313-win_amd64.whl

gllm_inference/builder/build_lm_invoker.pyi

@@ -1,5 +1,5 @@
 from _typeshed import Incomplete
-from gllm_inference.lm_invoker import AnthropicLMInvoker as AnthropicLMInvoker, AzureOpenAILMInvoker as AzureOpenAILMInvoker, BedrockLMInvoker as BedrockLMInvoker, DatasaurLMInvoker as DatasaurLMInvoker, GoogleLMInvoker as GoogleLMInvoker, LangChainLMInvoker as LangChainLMInvoker, LiteLLMLMInvoker as LiteLLMLMInvoker, OpenAIChatCompletionsLMInvoker as OpenAIChatCompletionsLMInvoker, 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, PortkeyLMInvoker as PortkeyLMInvoker, 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
@@ -14,11 +14,15 @@ class Key:
     AZURE_DEPLOYMENT: str
     AZURE_ENDPOINT: str
     BASE_URL: str
+    CONFIG: str
+    CUSTOM_HOST: str
     CREDENTIALS_PATH: str
     MODEL_ID: str
     MODEL_KWARGS: str
     MODEL_NAME: str
     MODEL_CLASS_PATH: str
+    PORTKEY_API_KEY: str
+    PROVIDER: str
     SECRET_ACCESS_KEY: str
 
 def build_lm_invoker(model_id: str | ModelId, credentials: str | dict[str, Any] | None = None, config: dict[str, Any] | None = None) -> BaseLMInvoker:
@@ -157,6 +161,61 @@ def build_lm_invoker(model_id: str | ModelId, credentials: str | dict[str, Any]
         For the list of supported providers, please refer to the following page:
         https://docs.litellm.ai/docs/providers/
 
+        # Using Portkey
+        Portkey supports multiple authentication methods with strict precedence order.
+        Authentication methods are mutually exclusive and cannot be combined.
+
+        ## Config ID Authentication (Highest Precedence)
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="portkey/any-model",
+            credentials="portkey-api-key",
+            config={"config": "pc-openai-4f6905"}
+        )
+        ```
+
+        ## Model Catalog Authentication (Combined Format)
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="portkey/@openai-custom/gpt-4o",
+            credentials="portkey-api-key"
+        )
+        ```
+
+        ## Model Catalog Authentication (Separate Parameters)
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="portkey/gpt-4o",
+            credentials="portkey-api-key",
+            config={"provider": "@openai-custom"}
+        )
+        ```
+
+        ## Direct Provider Authentication
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="portkey/gpt-4o",
+            credentials={
+                "portkey_api_key": "portkey-api-key",
+                "api_key": "sk-...",  # Provider\'s API key
+                "provider": "openai"  # Direct provider (no \'@\' prefix)
+            }
+        )
+        ```
+
+        ## Custom Host Override
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="portkey/@custom-provider/gpt-4o",
+            credentials="portkey-api-key",
+            config={"custom_host": "https://your-custom-endpoint.com"}
+        )
+        ```
+
+        The Portkey API key can also be provided through the `PORTKEY_API_KEY` environment variable.
+        For more details on authentication methods, please refer to:
+        https://portkey.ai/docs/product/ai-gateway/universal-api
+
         # Using xAI
         ```python
         lm_invoker = build_lm_invoker(

gllm_inference/lm_invoker/__init__.pyi

@@ -8,6 +8,7 @@ from gllm_inference.lm_invoker.litellm_lm_invoker import LiteLLMLMInvoker as Lit
 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.portkey_lm_invoker import PortkeyLMInvoker as PortkeyLMInvoker
 from gllm_inference.lm_invoker.xai_lm_invoker import XAILMInvoker as XAILMInvoker
 
-__all__ = ['AnthropicLMInvoker', 'AzureOpenAILMInvoker', 'BedrockLMInvoker', 'DatasaurLMInvoker', 'GoogleLMInvoker', 'LangChainLMInvoker', 'LiteLLMLMInvoker', 'OpenAIChatCompletionsLMInvoker', 'OpenAICompatibleLMInvoker', 'OpenAILMInvoker', 'XAILMInvoker']
+__all__ = ['AnthropicLMInvoker', 'AzureOpenAILMInvoker', 'BedrockLMInvoker', 'DatasaurLMInvoker', 'GoogleLMInvoker', 'LangChainLMInvoker', 'LiteLLMLMInvoker', 'OpenAIChatCompletionsLMInvoker', 'OpenAICompatibleLMInvoker', 'OpenAILMInvoker', 'PortkeyLMInvoker', 'XAILMInvoker']

gllm_inference/lm_invoker/portkey_lm_invoker.pyi

@@ -0,0 +1,260 @@
+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 SECONDS_TO_MILLISECONDS as SECONDS_TO_MILLISECONDS
+from gllm_inference.lm_invoker.openai_chat_completions_lm_invoker import OpenAIChatCompletionsLMInvoker as OpenAIChatCompletionsLMInvoker
+from gllm_inference.lm_invoker.schema.portkey import InputType as InputType, Key as Key
+from gllm_inference.schema import AttachmentType as AttachmentType, LMOutput as LMOutput, ModelId as ModelId, ModelProvider as ModelProvider, ResponseSchema as ResponseSchema
+from langchain_core.tools import Tool as LangChainTool
+from typing import Any
+
+MIN_THINKING_BUDGET: int
+SUPPORTED_ATTACHMENTS: Incomplete
+VALID_AUTH_METHODS: str
+logger: Incomplete
+
+class PortkeyLMInvoker(OpenAIChatCompletionsLMInvoker):
+    '''A language model invoker to interact with Portkey\'s Universal API.
+
+    This class provides support for Portkey’s Universal AI Gateway, which enables unified access to
+    multiple providers (e.g., OpenAI, Anthropic, Google, Cohere, Bedrock) via a single API key.
+    The `PortkeyLMInvoker` is compatible with all Portkey model routing configurations, including
+    model catalog entries, direct providers, and pre-defined configs.
+
+    Attributes:
+        model_id (str): The model ID of the language model.
+        model_provider (str): The provider of the language model.
+        model_name (str): The catalog name of the language model.
+        client_kwargs (dict[str, Any]): The keyword arguments for the Portkey client.
+        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): The retry configuration for the language model.
+        thinking (bool): Whether to enable thinking mode for supported models.
+        thinking_budget (int): The maximum reasoning token budget for thinking mode.
+
+    Basic usage:
+        The `PortkeyLMInvoker` supports multiple authentication methods with strict precedence order.
+        Authentication methods are mutually exclusive and cannot be combined.
+
+        **Authentication Precedence (Highest to Lowest):**
+        1. **Config ID Authentication (Highest precedence)**
+           Use a pre-configured routing setup from Portkey’s dashboard.
+           ```python
+           lm_invoker = PortkeyLMInvoker(
+               portkey_api_key="<your-portkey-api-key>",
+               config="pc-openai-4f6905",
+           )
+           ```
+
+        2. **Model Catalog Authentication**
+           Provider name must match the provider name set in the model catalog.
+           More details to set up the model catalog can be found in https://portkey.ai/docs/product/model-catalog#model-catalog.
+           There are two ways to specify the model name:
+
+           2.1. Using Combined Model Name Format
+           Specify the `model_name` in \'@provider-name/model-name\' format.
+           ```python
+           lm_invoker = PortkeyLMInvoker(
+               portkey_api_key="<your-portkey-api-key>",
+               model_name="@openai-custom/gpt-4o"
+           )
+           ```
+
+           2.2. Using Separate Provider and Model Name Parameters
+           Specify the `provider` in \'@provider-name\' format and `model_name` separately.
+           ```python
+           lm_invoker = PortkeyLMInvoker(
+               portkey_api_key="<your-portkey-api-key>",
+               provider="@openai-custom",
+               model_name="gpt-4o",
+           )
+           ```
+
+        3. **Direct Provider Authentication**
+           Use the `provider` in \'provider-name\' format and `model_name` parameters.
+           ```python
+           lm_invoker = PortkeyLMInvoker(
+               portkey_api_key="<your-portkey-api-key>",
+               provider="openai",
+               model_name="gpt-4o",
+               api_key="sk-...",
+           )
+           ```
+
+    Custom Host:
+        You can also use the `custom_host` parameter to override the default host. This is available
+        for all authentication methods except for Config ID authentication.
+        ```python
+        lm_invoker = PortkeyLMInvoker(..., custom_host="https://your-custom-endpoint.com")
+        ```
+
+    Input types:
+        The `PortkeyLMInvoker` supports text, image, document, and audio inputs.
+        Non-text inputs can be passed as an `Attachment` object with the `user` role.
+
+        ```python
+        text = "What animal is in this image?"
+        image = Attachment.from_path("path/to/image.png")
+        result = await lm_invoker.invoke([text, image])
+        ```
+
+    Tool calling:
+        Tools can be provided via the `tools` parameter to enable tool invocation.
+
+        ```python
+        lm_invoker = PortkeyLMInvoker(..., 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"}),
+            ]
+        )
+        ```
+
+    Structured output:
+        The `response_schema` parameter enables structured responses (Pydantic BaseModel or JSON schema).
+
+        ```python
+        class Animal(BaseModel):
+            name: str
+            color: str
+        lm_invoker = PortkeyLMInvoker(..., response_schema=Animal)
+        ```
+        Output example:
+        ```python
+        LMOutput(structured_output=Animal(name="Golden retriever", color="Golden"))
+        ```
+
+    Analytics tracking:
+        When `output_analytics=True`, the invoker includes token usage, duration, and finish details.
+
+        ```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"},
+        )
+        ```
+
+        **Note:** When streaming is enabled, token usage analytics are not supported and will be `None`.
+
+    Retry and timeout:
+        The `PortkeyLMInvoker` 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=None)  # 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=None)  # 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 = PortkeyLMInvoker(..., retry_config=retry_config)
+        ```
+
+    Thinking:
+        The `thinking` parameter enables enhanced reasoning capability for supported models.
+        Thinking mode allocates additional “reasoning tokens” up to `thinking_budget` (minimum 1024).
+        When enabled, the model’s reasoning trace is stored in the `reasoning` attribute.
+
+        ```python
+        lm_invoker = PortkeyLMInvoker(..., thinking=True, thinking_budget=1024)
+        ```
+        Output example:
+        ```python
+        LMOutput(
+            response="Golden retriever is a good dog breed.",
+            reasoning=[Reasoning(reasoning="Let me think about it...")],
+        )
+        ```
+
+        Streaming output example:
+        ```python
+        {"type": "thinking_start", "value": ""}
+        {"type": "thinking", "value": "Let me think "}
+        {"type": "thinking", "value": "about it..."}
+        {"type": "thinking_end", "value": ""}
+        {"type": "response", "value": "Golden retriever "}
+        {"type": "response", "value": "is a good dog breed."}
+        ```
+
+        Note: By default, the thinking token will be streamed with the legacy `EventType.DATA` event type.
+        To use the new simplified streamed event format, set the `simplify_events` parameter to `True` during
+        LM invoker initialization. The legacy event format support will be removed in v0.6.
+
+        When thinking is enabled, the amount of tokens allocated for the thinking process can be set via the
+        `thinking_budget` parameter. The `thinking_budget`:
+        1. Must be a positive integer.
+        2. Must be at least 1024.
+        3. Must be less than or equal to the model\'s maximum context length.
+        For more information, please refer to https://portkey.ai/docs/product/ai-gateway/multimodal-capabilities/thinking-mode
+
+        Setting reasoning-related parameters for non-reasoning models will raise an error.
+
+    Output types:
+        The output of the `PortkeyLMInvoker` can either be:
+        1. `str`: A simple text response.
+        2. `LMOutput`: A structured response model that may contain:
+            2.1. response (str)
+            2.2. tool_calls (list[ToolCall])
+            2.3. structured_output (dict[str, Any] | BaseModel | None)
+            2.4. token_usage (TokenUsage | None)
+            2.5. duration (float | None)
+            2.6. finish_details (dict[str, Any] | None)
+            2.7. reasoning (list[Reasoning])
+    '''
+    model_kwargs: Incomplete
+    thinking: Incomplete
+    thinking_budget: Incomplete
+    client_kwargs: Incomplete
+    client: Incomplete
+    def __init__(self, model_name: str | None = None, portkey_api_key: str | None = None, provider: str | None = None, api_key: str | None = None, config: str | None = None, custom_host: 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, thinking: bool | None = None, thinking_budget: int | None = None, simplify_events: bool = False) -> None:
+        """Initializes a new instance of the PortkeyLMInvoker class.
+
+        Args:
+            model_name (str | None, optional): The name of the model to use. Acceptable formats:
+                1. 'model' for direct authentication,
+                2. '@provider-slug/model' for model catalog authentication.
+                Defaults to None.
+            portkey_api_key (str | None, optional): The Portkey API key. Defaults to None, in which
+                case the `PORTKEY_API_KEY` environment variable will be used.
+            provider (str | None, optional): Provider name or catalog slug. Acceptable formats:
+                1. '@provider-slug' for model catalog authentication (no api_key needed),
+                2. 'provider' for direct authentication (requires api_key).
+                Will be combined with model_name if model name is not in the format '@provider-slug/model'.
+                Defaults to None.
+            api_key (str | None, optional): Provider's API key for direct authentication.
+                Must be used with 'provider' parameter (without '@' prefix). Not needed for catalog providers.
+                Defaults to None.
+            config (str | None, optional): Portkey config ID for complex routing configurations,
+                load balancing, or fallback scenarios. Defaults to None.
+            custom_host (str | None, optional): Custom host URL for self-hosted or custom endpoints.
+                Can be combined with catalog providers. Defaults to None.
+            model_kwargs (dict[str, Any] | None, optional): Additional model parameters and authentication.
+                Defaults to None.
+            default_hyperparameters (dict[str, Any] | None, optional): Default hyperparameters for model
+                invocation (temperature, max_tokens, etc.). Defaults to None.
+            tools (list[Tool | LangChainTool] | None, optional): Tools for enabling tool calling functionality.
+                Defaults to None.
+            response_schema (ResponseSchema | None, optional): Schema for structured output generation.
+                Defaults to None.
+            output_analytics (bool, optional): Whether to output detailed invocation analytics including
+                token usage and timing. Defaults to False.
+            retry_config (RetryConfig | None, optional): Configuration for retry behavior on failures.
+                Defaults to None.
+            thinking (bool | None, optional): Whether to enable thinking mode. Defaults to None.
+            thinking_budget (int | None, optional): Thinking budget in tokens. Defaults to None.
+            simplify_events (bool, optional): Whether to use simplified event schemas. Defaults to False.
+        """

gllm_inference/lm_invoker/schema/portkey.pyi

@@ -0,0 +1,31 @@
+class Key:
+    """Valid keys in Portkey."""
+    AUTHORIZATION: str
+    BUDGET_TOKENS: str
+    CONFIG: str
+    CONTENT: str
+    CONTENT_BLOCKS: str
+    CUSTOM_HOST: str
+    DELTA: str
+    MAX_RETRIES: str
+    MODEL: str
+    PROVIDER: str
+    PROVIDER_MODEL: str
+    REQUEST_TIMEOUT: str
+    RESPONSE_FORMAT: str
+    STRICT_OPEN_AI_COMPLIANCE: str
+    THINKING: str
+    TOOLS: str
+    TYPE: str
+    USAGE: str
+
+class InputType:
+    """Valid input types in Portkey."""
+    ENABLED: str
+
+class AuthConfig:
+    """Authentication configuration keys."""
+    CONFIG: str
+    MODEL: str
+    PROVIDER_AUTH: str
+    PROVIDER_CUSTOM_HOST: str

gllm_inference/prompt_builder/format_strategy/__init__.pyi

@@ -0,0 +1,4 @@
+from gllm_inference.prompt_builder.format_strategy.jinja_format_strategy import JinjaFormatStrategy as JinjaFormatStrategy
+from gllm_inference.prompt_builder.format_strategy.string_format_strategy import StringFormatStrategy as StringFormatStrategy
+
+__all__ = ['StringFormatStrategy', 'JinjaFormatStrategy']

gllm_inference/prompt_builder/format_strategy/format_strategy.pyi

@@ -0,0 +1,55 @@
+import abc
+from _typeshed import Incomplete
+from abc import ABC, abstractmethod
+from gllm_inference.schema.message import MessageContent as MessageContent
+
+class BasePromptFormattingStrategy(ABC, metaclass=abc.ABCMeta):
+    """Base class for prompt formatting strategies.
+
+    This class defines the interface for different prompt templating engines. Subclasses
+    implement specific formatting strategies to render templates with variable
+    substitution.
+
+    The strategy pattern allows the PromptBuilder to work with different templating engines
+    without changing its core logic.
+
+    Attributes:
+        key_defaults (dict[str, str]): The default values for the keys.
+    """
+    key_defaults: Incomplete
+    def __init__(self, key_defaults: dict[str, str] | None = None) -> None:
+        """Initialize the BasePromptFormattingStrategy.
+
+        Args:
+            key_defaults (dict[str, str] | None, optional): The default values for the keys. Defaults to None,
+                in which case no default values are used.
+        """
+    def format(self, template: str, variables_map: dict[str, str] | None = None, extra_contents: list[MessageContent] | None = None) -> list[str]:
+        """Format template with variables using the template method pattern.
+
+        This is a template method that defines the algorithm for formatting:
+        1. Merge key_defaults and variables_map
+        2. Render the template (delegated to subclass via _render_template)
+        3. Append extra_contents to the result
+
+        Args:
+            template (str): Template string to format.
+            variables_map (dict[str, str] | None, optional): Variables for substitution. Defaults to None.
+            extra_contents (list[MessageContent] | None, optional): Extra contents to format. Defaults to None.
+
+        Returns:
+            str: Formatted template string.
+        """
+    @abstractmethod
+    def extract_keys(self, template: str | None) -> set[str]:
+        """Extract variable keys from template.
+
+        Args:
+            template (str | None): Template string to extract keys from.
+
+        Returns:
+            set[str]: Set of variable keys found in template.
+
+        Raises:
+            NotImplementedError: If the method is not implemented.
+        """

gllm_inference/prompt_builder/format_strategy/jinja_format_strategy.pyi

@@ -0,0 +1,45 @@
+from _typeshed import Incomplete
+from gllm_inference.prompt_builder.format_strategy.format_strategy import BasePromptFormattingStrategy as BasePromptFormattingStrategy
+from gllm_inference.schema import JinjaEnvType as JinjaEnvType
+from jinja2.sandbox import SandboxedEnvironment
+from typing import Any
+
+JINJA_DEFAULT_BLACKLISTED_FILTERS: list[str]
+JINJA_DEFAULT_SAFE_GLOBALS: dict[str, Any]
+JINJA_DANGEROUS_PATTERNS: list[str]
+PROMPT_BUILDER_VARIABLE_START_STRING: str
+PROMPT_BUILDER_VARIABLE_END_STRING: str
+
+class JinjaFormatStrategy(BasePromptFormattingStrategy):
+    """Jinja2 template engine for formatting prompts.
+
+    Attributes:
+        jinja_env (SandboxedEnvironment): The Jinja environment for rendering templates.
+        key_defaults (dict[str, str]): The default values for the keys.
+    """
+    jinja_env: Incomplete
+    def __init__(self, environment: JinjaEnvType | SandboxedEnvironment = ..., key_defaults: dict[str, str] | None = None) -> None:
+        """Initialize the JinjaFormatStrategy.
+
+        Args:
+            environment (JinjaEnvType | SandboxedEnvironment, optional): The environment for Jinja rendering.
+                It can be one of the following:
+                1. `JinjaEnvType.RESTRICTED`: Uses a minimal, restricted Jinja environment.
+                        Safest for most cases.
+                2. `JinjaEnvType.JINJA_DEFAULT`: Uses the full Jinja environment. Allows more powerful templating,
+                        but with fewer safety restrictions.
+                3. `SandboxedEnvironment` instance: A custom Jinja `SandboxedEnvironment` object provided by the
+                        user. Offers fine-grained control over template execution.
+                Defaults to `JinjaEnvType.RESTRICTED`
+            key_defaults (dict[str, str], optional): The default values for the keys. Defaults to None, in which
+                case no default values are used.
+        """
+    def extract_keys(self, template: str | None) -> set[str]:
+        """Extract keys from Jinja template using AST analysis.
+
+        Args:
+            template (str | None): The template to extract keys from.
+
+        Returns:
+            set[str]: The set of keys found in the template.
+        """

gllm_inference/prompt_builder/format_strategy/string_format_strategy.pyi

@@ -0,0 +1,20 @@
+from _typeshed import Incomplete
+from gllm_inference.prompt_builder.format_strategy.format_strategy import BasePromptFormattingStrategy as BasePromptFormattingStrategy
+
+KEY_EXTRACTOR_REGEX: Incomplete
+
+class StringFormatStrategy(BasePromptFormattingStrategy):
+    """String format strategy using str.format() method.
+
+    Attributes:
+        key_defaults (dict[str, str]): The default values for the keys.
+    """
+    def extract_keys(self, template: str | None) -> set[str]:
+        """Extract keys from a template.
+
+        Args:
+            template (str | None): The template to extract keys from.
+
+        Returns:
+            set[str]: The set of keys found in the template.
+        """

gllm_inference/prompt_builder/prompt_builder.pyi

@@ -1,9 +1,9 @@
 from _typeshed import Incomplete
-from gllm_inference.schema import Message as Message, MessageContent as MessageContent, MessageRole as MessageRole
+from gllm_inference.prompt_builder.format_strategy import JinjaFormatStrategy as JinjaFormatStrategy, StringFormatStrategy as StringFormatStrategy
+from gllm_inference.schema import JinjaEnvType as JinjaEnvType, Message as Message, MessageContent as MessageContent, MessageRole as MessageRole
+from jinja2.sandbox import SandboxedEnvironment as SandboxedEnvironment
 from typing import Any
 
-KEY_EXTRACTOR_REGEX: Incomplete
-
 class PromptBuilder:
     """A prompt builder class used in Gen AI applications.
 
@@ -12,12 +12,14 @@ class PromptBuilder:
         user_template (str): The user prompt template. May contain placeholders enclosed in curly braces `{}`.
         prompt_key_set (set[str]): A set of expected keys that must be present in the prompt templates.
         key_defaults (dict[str, str]): Default values for the keys in the prompt templates.
+        strategy (BasePromptFormattingStrategy): The format strategy to be used for formatting the prompt.
     """
+    key_defaults: Incomplete
     system_template: Incomplete
     user_template: Incomplete
+    strategy: Incomplete
     prompt_key_set: Incomplete
-    key_defaults: Incomplete
-    def __init__(self, system_template: str = '', user_template: str = '', key_defaults: dict[str, str] | None = None, ignore_extra_keys: bool | None = None) -> None:
+    def __init__(self, system_template: str = '', user_template: str = '', key_defaults: dict[str, str] | None = None, ignore_extra_keys: bool | None = None, use_jinja: bool = False, jinja_env: JinjaEnvType | SandboxedEnvironment = ...) -> None:
         """Initializes a new instance of the PromptBuilder class.
 
         Args:
@@ -30,6 +32,17 @@ class PromptBuilder:
                 Defaults to None, in which case no default values will be assigned to the keys.
             ignore_extra_keys (bool | None, optional): Deprecated parameter. Will be removed in v0.6. Extra keys
                 will always raise a warning only instead of raising an error.
+            use_jinja (bool, optional): Whether to use Jinja for rendering the prompt templates.
+                Defaults to False.
+            jinja_env (JinjaEnvType | SandboxedEnvironment, optional): The environment for Jinja rendering.
+                It can be one of the following:
+                1. `JinjaEnvType.RESTRICTED`: Uses a minimal, restricted Jinja environment.
+                        Safest for most cases.
+                2. `JinjaEnvType.JINJA_DEFAULT`: Uses the full Jinja environment. Allows more powerful templating,
+                        but with fewer safety restrictions.
+                3. `SandboxedEnvironment` instance: A custom Jinja `SandboxedEnvironment` object provided by the
+                        user. Offers fine-grained control over template execution.
+                Defaults to `JinjaEnvType.RESTRICTED`
 
         Raises:
             ValueError: If both `system_template` and `user_template` are empty.
@@ -49,7 +62,7 @@ class PromptBuilder:
                 Values must be either a string or an object that can be serialized to a string.
 
         Returns:
-            list[Message]: A formatted list of messages.
+            list[Message]: A list of formatted messages.
 
         Raises:
             ValueError: If a required key for the prompt template is missing from `kwargs`.

gllm_inference/schema/__init__.pyi

@@ -2,7 +2,7 @@ from gllm_inference.schema.activity import Activity as Activity, MCPCallActivity
 from gllm_inference.schema.attachment import Attachment as Attachment
 from gllm_inference.schema.code_exec_result import CodeExecResult as CodeExecResult
 from gllm_inference.schema.config import TruncationConfig as TruncationConfig
-from gllm_inference.schema.enums import AttachmentType as AttachmentType, BatchStatus as BatchStatus, EmitDataType as EmitDataType, LMEventType as LMEventType, MessageRole as MessageRole, TruncateSide as TruncateSide
+from gllm_inference.schema.enums import AttachmentType as AttachmentType, BatchStatus as BatchStatus, EmitDataType as EmitDataType, JinjaEnvType as JinjaEnvType, LMEventType as LMEventType, MessageRole as MessageRole, TruncateSide as TruncateSide
 from gllm_inference.schema.events import ActivityEvent as ActivityEvent, CodeEvent as CodeEvent, ThinkingEvent as ThinkingEvent
 from gllm_inference.schema.lm_input import LMInput as LMInput
 from gllm_inference.schema.lm_output import LMOutput as LMOutput
@@ -15,4 +15,4 @@ from gllm_inference.schema.tool_call import ToolCall as ToolCall
 from gllm_inference.schema.tool_result import ToolResult as ToolResult
 from gllm_inference.schema.type_alias import EMContent as EMContent, MessageContent as MessageContent, ResponseSchema as ResponseSchema, Vector as Vector
 
-__all__ = ['Activity', 'ActivityEvent', 'Attachment', 'AttachmentType', 'BatchStatus', 'CodeEvent', 'CodeExecResult', 'EMContent', 'EmitDataType', 'LMEventType', 'InputTokenDetails', 'LMInput', 'LMOutput', 'MCPCall', 'MCPCallActivity', 'MCPListToolsActivity', 'MCPServer', 'Message', 'MessageContent', 'MessageRole', 'ModelId', 'ModelProvider', 'OutputTokenDetails', 'Reasoning', 'ThinkingEvent', 'ResponseSchema', 'TokenUsage', 'ToolCall', 'ToolResult', 'TruncateSide', 'TruncationConfig', 'Vector', 'WebSearchActivity']
+__all__ = ['Activity', 'ActivityEvent', 'Attachment', 'AttachmentType', 'BatchStatus', 'CodeEvent', 'CodeExecResult', 'EMContent', 'EmitDataType', 'LMEventType', 'InputTokenDetails', 'JinjaEnvType', 'LMInput', 'LMOutput', 'MCPCall', 'MCPCallActivity', 'MCPListToolsActivity', 'MCPServer', 'Message', 'MessageContent', 'MessageRole', 'ModelId', 'ModelProvider', 'OutputTokenDetails', 'Reasoning', 'ThinkingEvent', 'ResponseSchema', 'TokenUsage', 'ToolCall', 'ToolResult', 'TruncateSide', 'TruncationConfig', 'Vector', 'WebSearchActivity']

gllm_inference/schema/enums.pyi

@@ -54,6 +54,11 @@ class TruncateSide(StrEnum):
     RIGHT = 'RIGHT'
     LEFT = 'LEFT'
 
+class JinjaEnvType(StrEnum):
+    """Enumeration for Jinja environment types."""
+    JINJA_DEFAULT = 'jinja_default'
+    RESTRICTED = 'restricted'
+
 class WebSearchKey(StrEnum):
     """Defines valid web search keys."""
     PATTERN = 'pattern'

gllm_inference/schema/model_id.pyi

@@ -19,6 +19,7 @@ class ModelProvider(StrEnum):
     LANGCHAIN = 'langchain'
     LITELLM = 'litellm'
     OPENAI = 'openai'
+    PORTKEY = 'portkey'
     OPENAI_CHAT_COMPLETIONS = 'openai-chat-completions'
     OPENAI_COMPATIBLE = 'openai-compatible'
     TWELVELABS = 'twelvelabs'

gllm_inference.pyi

@@ -32,6 +32,7 @@ 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.PortkeyLMInvoker
 import gllm_inference.lm_invoker.XAILMInvoker
 import gllm_inference.prompt_builder.PromptBuilder
 import gllm_inference.output_parser.JSONOutputParser
@@ -125,15 +126,21 @@ import gllm_inference.schema.MCPCallActivity
 import gllm_inference.schema.MCPListToolsActivity
 import gllm_inference.schema.MCPServer
 import gllm_inference.schema.WebSearchActivity
+import logging
+import portkey_ai
 import xai_sdk
 import xai_sdk.chat
 import xai_sdk.search
 import xai_sdk.proto
 import xai_sdk.proto.v5
 import xai_sdk.proto.v5.chat_pb2
+import jinja2
+import jinja2.sandbox
+import gllm_inference.schema.JinjaEnvType
+import gllm_inference.prompt_builder.format_strategy.JinjaFormatStrategy
+import gllm_inference.prompt_builder.format_strategy.StringFormatStrategy
 import transformers
 import gllm_inference.prompt_formatter.HuggingFacePromptFormatter
-import logging
 import traceback
 import gllm_inference.realtime_chat.input_streamer.KeyboardInputStreamer
 import gllm_inference.realtime_chat.output_streamer.ConsoleOutputStreamer

{gllm_inference_binary-0.5.44.dist-info → gllm_inference_binary-0.5.46.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: gllm-inference-binary
-Version: 0.5.44
+Version: 0.5.46
 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
@@ -39,10 +39,12 @@ Requires-Dist: google-genai<=1.36,>=1.23; extra == "google"
 Provides-Extra: huggingface
 Requires-Dist: huggingface-hub<0.31.0,>=0.30.0; extra == "huggingface"
 Requires-Dist: transformers<5.0.0,>=4.52.0; extra == "huggingface"
-Provides-Extra: openai
-Requires-Dist: openai<2.0.0,>=1.98.0; extra == "openai"
 Provides-Extra: litellm
 Requires-Dist: litellm<2.0.0,>=1.69.2; extra == "litellm"
+Provides-Extra: openai
+Requires-Dist: openai<2.0.0,>=1.98.0; extra == "openai"
+Provides-Extra: portkey-ai
+Requires-Dist: portkey-ai<2.0.0,>=1.14.4; extra == "portkey-ai"
 Provides-Extra: twelvelabs
 Requires-Dist: twelvelabs<0.5.0,>=0.4.4; extra == "twelvelabs"
 Provides-Extra: voyage

{gllm_inference_binary-0.5.44.dist-info → gllm_inference_binary-0.5.46.dist-info}/RECORD

@@ -1,10 +1,10 @@
-gllm_inference.cp313-win_amd64.pyd,sha256=3Xnjm5F7tiaEIKRL19GPUPLSnwzUmugqGBtivByuSOs,3671552
-gllm_inference.pyi,sha256=PN9a6F49IGwGrPXny7b-knSKeGsO_ER8e9DaBqiOD2k,4918
+gllm_inference.cp313-win_amd64.pyd,sha256=FmGdE_EHin-8qlPX4uCTEXqCpQn9yIE_m6z171rHitM,3811840
+gllm_inference.pyi,sha256=1WeCtSLoqo97eCY-WiMP-LF9UUJG_pT5NTESuCoStRg,5211
 gllm_inference/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gllm_inference/constants.pyi,sha256=PncjVw-mkzcJ3ln1ohvVZGdJ-TD-VZy1Ygn4Va8Z7i0,350
 gllm_inference/builder/__init__.pyi,sha256=-bw1uDx7CAM7pkvjvb1ZXku9zXlQ7aEAyC83KIn3bz8,506
 gllm_inference/builder/build_em_invoker.pyi,sha256=3vO_pLokR4BAZflOMu6qzXoKx6vibT16uwJETH5Y_yc,6283
-gllm_inference/builder/build_lm_invoker.pyi,sha256=HvQICF-qvOTzfXZUqhi7rlwcpkMZpxaC-8QZmhnXKzI,7466
+gllm_inference/builder/build_lm_invoker.pyi,sha256=mGMFjTmflPjfz9gRhnLzfdAnumSGfLuXFt4W76ZHSJw,9520
 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
@@ -39,7 +39,7 @@ 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=vWa4ZIHn7qIghECGvO-dS2KzOmf3c10GRWKZ4YDPnSQ,1267
-gllm_inference/lm_invoker/__init__.pyi,sha256=jG1xc5fTOeIgeKKVYSnsMzQThKk9kTW38yO_MYtv540,1387
+gllm_inference/lm_invoker/__init__.pyi,sha256=L2nlkj13WwWbDYEBtM0mlAj0-UbSilMjVLpCJ_0Eock,1502
 gllm_inference/lm_invoker/anthropic_lm_invoker.pyi,sha256=JSgKUk9d1ZHlitv_ZjHlAk2hIW-J7u6yslVHflIeUro,16726
 gllm_inference/lm_invoker/azure_openai_lm_invoker.pyi,sha256=FYfRNPG-oD4wIfitjTHnGib1uMZL7Pid0gbrRsymAHU,14601
 gllm_inference/lm_invoker/bedrock_lm_invoker.pyi,sha256=dsNxj3ZfHxUplg6nBLgxVGooGYq1QP89gYzCnmRCz3g,11810
@@ -51,6 +51,7 @@ gllm_inference/lm_invoker/lm_invoker.pyi,sha256=PS4cJ5VLNfHqeTgCerY-c1Xaa7ktdWAi
 gllm_inference/lm_invoker/openai_chat_completions_lm_invoker.pyi,sha256=uYJFgi4tJGab77232IC1gdoU9h9AqoClIUj6tM6O47s,15177
 gllm_inference/lm_invoker/openai_compatible_lm_invoker.pyi,sha256=T9sShA_9fgEuaaAuT2gJZq_EYNbEhf3IkWwMCwfszY8,4244
 gllm_inference/lm_invoker/openai_lm_invoker.pyi,sha256=10iKCyleqHNbJc8M1rj3ogRcNlNxcVgyk0v6TcS6gf4,23452
+gllm_inference/lm_invoker/portkey_lm_invoker.pyi,sha256=BmZ5TFiQx3-6Ijf6J2ICzP6SCfnOFUVTPRLijv85oU0,13465
 gllm_inference/lm_invoker/xai_lm_invoker.pyi,sha256=gyi12K7M9HkjNX6pU6NVv5Uq3-aHErixO-PVhHjioo8,14632
 gllm_inference/lm_invoker/batch/__init__.pyi,sha256=vJOTHRJ83oq8Bq0UsMdID9_HW5JAxr06gUs4aPRZfEE,130
 gllm_inference/lm_invoker/batch/batch_operations.pyi,sha256=o2U17M41RKVFW6j_oxy-SxU1JqUtVt75pKRxrqXzorE,5499
@@ -62,6 +63,7 @@ gllm_inference/lm_invoker/schema/google.pyi,sha256=elXHrUMS46pbTsulk7hBXVVFcT022
 gllm_inference/lm_invoker/schema/langchain.pyi,sha256=2OJOUQPlGdlUbIOTDOyiWDBOMm3MoVX-kU2nK0zQsF0,452
 gllm_inference/lm_invoker/schema/openai.pyi,sha256=TsCr8_SM5kK2JyROeXtmH13n46TgKjLMc0agYlYUSZc,2328
 gllm_inference/lm_invoker/schema/openai_chat_completions.pyi,sha256=nNPb7ETC9IrJwkV5wfbGf6Co3-qdq4lhcXz0l_qYCE4,1261
+gllm_inference/lm_invoker/schema/portkey.pyi,sha256=V2q4JIwDAR7BidqfmO01u1_1mLOMtm5OCon6sN2zNt0,662
 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
@@ -77,7 +79,11 @@ gllm_inference/output_parser/__init__.pyi,sha256=dhAeRTBxc6CfS8bhnHjbtrnyqJ1iyff
 gllm_inference/output_parser/json_output_parser.pyi,sha256=YtgQh8Uzy8W_Tgh8DfuR7VFFS7qvLEasiTwRfaGZZEU,2993
 gllm_inference/output_parser/output_parser.pyi,sha256=-Xu5onKCBDqShcO-VrQh5icqAmXdihGc3rkZxL93swg,975
 gllm_inference/prompt_builder/__init__.pyi,sha256=mPsbiafzSNHsgN-CuzjhgZpfXfi1pPC3_gdsq2p0EM4,120
-gllm_inference/prompt_builder/prompt_builder.pyi,sha256=ju52smKHT_Bh2EVMZBWe1Z0ZQjD5aPBDLI_xLaILcgo,3334
+gllm_inference/prompt_builder/prompt_builder.pyi,sha256=67X0MXPRGb_Azifk5fM9lAsQX48rASsQk2gCPikqU5k,4626
+gllm_inference/prompt_builder/format_strategy/__init__.pyi,sha256=BliNAdrN2yNoQt8muLe1IknuE78UDQys_3L_8_2Tn9E,312
+gllm_inference/prompt_builder/format_strategy/format_strategy.pyi,sha256=Uay07qR0nMGbrOZ2twEyrIWYRKevBQL9ju_4fVfByyQ,2328
+gllm_inference/prompt_builder/format_strategy/jinja_format_strategy.pyi,sha256=W8SdOPWPz_U355G8rQwiIQ0Ys78vomUBFEEZiz3AS5k,2270
+gllm_inference/prompt_builder/format_strategy/string_format_strategy.pyi,sha256=Xbx8xAtj3AbgFuPY8A3OuC6MlwenjYm6OXnQwxAP45k,713
 gllm_inference/prompt_formatter/__init__.pyi,sha256=q5sPPrnoCf-4tMGowh7hXxs63uyWfaZyEI-wjLBTGsA,747
 gllm_inference/prompt_formatter/agnostic_prompt_formatter.pyi,sha256=qp4L3x7XK7oZaSYP8B4idewKpPioB4XELeKVV-dNi-Q,2067
 gllm_inference/prompt_formatter/huggingface_prompt_formatter.pyi,sha256=kH60A_3DnHd3BrqbgS_FqQTCTHIjC9BTsk6_FNgcZw8,2784
@@ -99,18 +105,18 @@ gllm_inference/realtime_chat/output_streamer/output_streamer.pyi,sha256=5P9NQ0aJ
 gllm_inference/request_processor/__init__.pyi,sha256=giEme2WFQhgyKiBZHhSet0_nKSCHwGy-_2p6NRzg0Zc,231
 gllm_inference/request_processor/lm_request_processor.pyi,sha256=0fy1HyILCVDw6y46E-7tLnQTRYx4ppeRMe0QP6t9Jyw,5990
 gllm_inference/request_processor/uses_lm_mixin.pyi,sha256=LYHq-zLoXEMel1LfVdYv7W3BZ8WtBLo_WWFjRf10Yto,6512
-gllm_inference/schema/__init__.pyi,sha256=cGEeGc5xDyfepbCi5r_c61VmS6VnWyvoRjjK7K13lLg,2177
+gllm_inference/schema/__init__.pyi,sha256=Rv821pgyUUbcVhnGJ0CnXVWJMi2pgaglv6Pq4RHK7yE,2223
 gllm_inference/schema/activity.pyi,sha256=atrU4OwLesA9FEt1H7K3gsUWYNdOqpI5i2VdWkmo6cs,2367
 gllm_inference/schema/attachment.pyi,sha256=9zgAjGXBjLfzPGaKi68FMW6b5mXdEA352nDe-ynOSvY,3385
 gllm_inference/schema/code_exec_result.pyi,sha256=WQ-ARoGM9r6nyRX-A0Ro1XKiqrc9R3jRYXZpu_xo5S4,573
 gllm_inference/schema/config.pyi,sha256=NVmjQK6HipIE0dKSfx12hgIC0O-S1HEcAc-TWlXAF5A,689
-gllm_inference/schema/enums.pyi,sha256=zuKgBxcm0GXvyEZag3FAETFTG-uikgjGJ5QRoXluSZg,1675
+gllm_inference/schema/enums.pyi,sha256=dN6FzT4zNbSfqVxmrl3hO7IIiP-Qy4lAP_tf4tp8dNI,1827
 gllm_inference/schema/events.pyi,sha256=iG3sFAhvek-fSJgmUE6nJ5M0XzSpRKKpJJiXyuB4Wq0,5058
 gllm_inference/schema/lm_input.pyi,sha256=HxQiZgY7zcXh_Dw8nK8LSeBTZEHMPZVwmPmnfgSsAbs,197
 gllm_inference/schema/lm_output.pyi,sha256=DIV8BiIOPaSnMKxzKzH_Mp7j7-MScWCvmllegJDLqFg,2479
 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=3PeAHrCyMAZJPCa7CfaArmOHdh2oDdUu6lkyx9mKG9g,5819
+gllm_inference/schema/model_id.pyi,sha256=Y9YjIOB5dRhs8EskAxoruFAzX0P3eu_xKD1huRM787M,5844
 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
@@ -121,7 +127,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.44.dist-info/METADATA,sha256=k03CIyjygon71qyD5--ATKsmuR5bi1IZyMotR-Gyqes,5852
-gllm_inference_binary-0.5.44.dist-info/WHEEL,sha256=O_u6PJIQ2pIcyIInxVQ9r-yArMuUZbBIaF1kpYVkYxA,96
-gllm_inference_binary-0.5.44.dist-info/top_level.txt,sha256=FpOjtN80F-qVNgbScXSEyqa0w09FYn6301iq6qt69IQ,15
-gllm_inference_binary-0.5.44.dist-info/RECORD,,
+gllm_inference_binary-0.5.46.dist-info/METADATA,sha256=e97z4bJANZaeXxjyXY_wSvyxm-n7WbAOCXkCnRbcSYY,5945
+gllm_inference_binary-0.5.46.dist-info/WHEEL,sha256=O_u6PJIQ2pIcyIInxVQ9r-yArMuUZbBIaF1kpYVkYxA,96
+gllm_inference_binary-0.5.46.dist-info/top_level.txt,sha256=FpOjtN80F-qVNgbScXSEyqa0w09FYn6301iq6qt69IQ,15
+gllm_inference_binary-0.5.46.dist-info/RECORD,,