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

gllm_inference/realtime_chat/google_realtime_chat.pyi

@@ -0,0 +1,205 @@
+import asyncio
+import logging
+from _typeshed import Incomplete
+from gllm_inference.constants import GOOGLE_SCOPES as GOOGLE_SCOPES
+from gllm_inference.realtime_chat.input_streamer import KeyboardInputStreamer as KeyboardInputStreamer
+from gllm_inference.realtime_chat.input_streamer.input_streamer import BaseInputStreamer as BaseInputStreamer
+from gllm_inference.realtime_chat.output_streamer import ConsoleOutputStreamer as ConsoleOutputStreamer
+from gllm_inference.realtime_chat.output_streamer.output_streamer import BaseOutputStreamer as BaseOutputStreamer
+from gllm_inference.realtime_chat.realtime_chat import BaseRealtimeChat as BaseRealtimeChat
+from pydantic import BaseModel
+from typing import Literal
+
+DEFAULT_POST_OUTPUT_AUDIO_DELAY: float
+LIVE_CONNECT_CONFIG: Incomplete
+
+class GoogleIOStreamerState(BaseModel):
+    '''[BETA] Defines the state of the GoogleIOStreamer with thread-safe properties.
+
+    Attributes:
+        is_streaming_output (bool): Whether the output is streaming.
+        console_mode (Literal["input", "user", "assistant"]): The current console mode.
+        terminated (bool): Whether the conversation is terminated.
+    '''
+    is_streaming_output: bool
+    console_mode: Literal['input', 'user', 'assistant']
+    terminated: bool
+    async def set_streaming_output(self, value: bool) -> None:
+        """Thread-safe setter for is_streaming_output.
+
+        Args:
+            value (bool): The value to set for is_streaming_output.
+        """
+    async def get_streaming_output(self) -> bool:
+        """Thread-safe getter for is_streaming_output.
+
+        Returns:
+            bool: The value of is_streaming_output.
+        """
+    async def set_console_mode(self, value: Literal['input', 'user', 'assistant']) -> None:
+        '''Thread-safe setter for console_mode.
+
+        Args:
+            value (Literal["input", "user", "assistant"]): The value to set for console_mode.
+        '''
+    async def get_console_mode(self) -> Literal['input', 'user', 'assistant']:
+        '''Thread-safe getter for console_mode.
+
+        Returns:
+            Literal["input", "user", "assistant"]: The value of console_mode.
+        '''
+    async def set_terminated(self, value: bool) -> None:
+        """Thread-safe setter for terminated.
+
+        Args:
+            value (bool): The value to set for terminated.
+        """
+    async def get_terminated(self) -> bool:
+        """Thread-safe getter for terminated.
+
+        Returns:
+            bool: The value of terminated.
+        """
+
+class GoogleIOStreamer:
+    """[BETA] Defines the GoogleIOStreamer.
+
+    This class manages the realtime conversation lifecycle.
+    It handles the IO operations between the model and the input/output streamers.
+
+    Attributes:
+        session (AsyncSession): The session of the GoogleIOStreamer.
+        task_group (asyncio.TaskGroup): The task group of the GoogleIOStreamer.
+        input_queue (asyncio.Queue): The input queue of the GoogleIOStreamer.
+        output_queue (asyncio.Queue): The output queue of the GoogleIOStreamer.
+        input_streamers (list[BaseInputStreamer]): The input streamers of the GoogleIOStreamer.
+        output_streamers (list[BaseOutputStreamer]): The output streamers of the GoogleIOStreamer.
+        post_output_audio_delay (float): The delay in seconds to post the output audio.
+    """
+    session: AsyncSession
+    task_group: Incomplete
+    input_queue: Incomplete
+    output_queue: Incomplete
+    state: Incomplete
+    input_streamers: Incomplete
+    output_streamers: Incomplete
+    post_output_audio_delay: Incomplete
+    def __init__(self, session: AsyncSession, task_group: asyncio.TaskGroup, input_queue: asyncio.Queue, output_queue: asyncio.Queue, input_streamers: list[BaseInputStreamer], output_streamers: list[BaseOutputStreamer], post_output_audio_delay: float, logger: logging.Logger) -> None:
+        """Initializes a new instance of the GoogleIOStreamer class.
+
+        Args:
+            session (AsyncSession): The session of the GoogleIOStreamer.
+            task_group (asyncio.TaskGroup): The task group of the GoogleIOStreamer.
+            input_queue (asyncio.Queue): The input queue of the GoogleIOStreamer.
+            output_queue (asyncio.Queue): The output queue of the GoogleIOStreamer.
+            input_streamers (list[BaseInputStreamer]): The input streamers of the GoogleIOStreamer.
+            output_streamers (list[BaseOutputStreamer]): The output streamers of the GoogleIOStreamer.
+            post_output_audio_delay (float): The delay in seconds to post the output audio.
+            logger (logging.Logger): The logger of the GoogleIOStreamer.
+        """
+    async def start(self) -> None:
+        """Processes the realtime conversation.
+
+        This method is used to start the realtime conversation.
+        It initializes the input and output streamers, creates the necessary tasks, and starts the conversation.
+        When the conversation is terminated, it cleans up the input and output streamers.
+        """
+
+class GoogleRealtimeChat(BaseRealtimeChat):
+    '''[BETA] A realtime chat module to interact with Gemini Live models.
+
+    Warning:
+        The \'GoogleRealtimeChat\' class is currently in beta and may be subject to changes in the future.
+        It is intended only for quick prototyping in local environments.
+        Please avoid using it in production environments.
+
+    Attributes:
+        model_name (str): The name of the language model.
+        client_params (dict[str, Any]): The Google client instance init parameters.
+
+    Basic usage:
+        The `GoogleRealtimeChat` can be used as started as follows:
+        ```python
+        realtime_chat = GoogleRealtimeChat(model_name="gemini-live-2.5-flash-preview")
+        await realtime_chat.invoke()
+        ```
+
+    Custom IO streamers:
+        The `GoogleRealtimeChat` can be used with custom IO streamers.
+        ```python
+        input_streamers = [KeyboardInputStreamer(), LinuxMicInputStreamer()]
+        output_streamers = [ConsoleOutputStreamer(), LinuxSpeakerOutputStreamer()]
+        realtime_chat = GoogleRealtimeChat(model_name="gemini-live-2.5-flash-preview")
+        await realtime_chat.start(input_streamers=input_streamers, output_streamers=output_streamers)
+        ```
+
+        In the above example, we added a capability to use a Linux system microphone and speaker,
+        allowing realtime audio input and output to the model.
+
+    Authentication:
+        The `GoogleRealtimeChat` can use either Google Gen AI or Google Vertex AI.
+
+        Google Gen AI is recommended for quick prototyping and development.
+        It requires a Gemini API key for authentication.
+
+        Usage example:
+        ```python
+        realtime_chat = GoogleRealtimeChat(
+            model_name="gemini-live-2.5-flash-preview",
+            api_key="your_api_key"
+        )
+        ```
+
+        Google Vertex AI is recommended to build production-ready applications.
+        It requires a service account JSON file for authentication.
+
+        Usage example:
+        ```python
+        realtime_chat = GoogleRealtimeChat(
+            model_name="gemini-live-2.5-flash-preview",
+            credentials_path="path/to/service_account.json"
+        )
+        ```
+
+        If neither `api_key` nor `credentials_path` is provided, Google Gen AI will be used by default.
+        The `GOOGLE_API_KEY` environment variable will be used for authentication.
+    '''
+    model_name: Incomplete
+    client_params: Incomplete
+    def __init__(self, model_name: str, api_key: str | None = None, credentials_path: str | None = None, project_id: str | None = None, location: str = 'us-central1') -> None:
+        '''Initializes a new instance of the GoogleRealtimeChat class.
+
+        Args:
+            model_name (str): The name of the model to use.
+            api_key (str | None, optional): Required for Google Gen AI authentication. Cannot be used together
+                with `credentials_path`. Defaults to None.
+            credentials_path (str | None, optional): Required for Google Vertex AI authentication. Path to the service
+                account credentials JSON file. Cannot be used together with `api_key`. Defaults to None.
+            project_id (str | None, optional): The Google Cloud project ID for Vertex AI. Only used when authenticating
+                with `credentials_path`. Defaults to None, in which case it will be loaded from the credentials file.
+            location (str, optional): The location of the Google Cloud project for Vertex AI. Only used when
+                authenticating with `credentials_path`. Defaults to "us-central1".
+
+        Note:
+            If neither `api_key` nor `credentials_path` is provided, Google Gen AI will be used by default.
+            The `GOOGLE_API_KEY` environment variable will be used for authentication.
+        '''
+    async def start(self, input_streamers: list[BaseInputStreamer] | None = None, output_streamers: list[BaseOutputStreamer] | None = None, post_output_audio_delay: float = ...) -> None:
+        """Starts the realtime conversation using the provided input and output streamers.
+
+        This method is used to start the realtime conversation using a `GoogleIOStreamer`.
+        The streamers are responsible for handling the input and output of the conversation.
+
+        Args:
+            input_streamers (list[BaseInputStreamer] | None, optional): The input streamers to use.
+                Defaults to None, in which case a `KeyboardInputStreamer` will be used.
+            output_streamers (list[BaseOutputStreamer] | None, optional): The output streamers to use.
+                Defaults to None, in which case a `ConsoleOutputStreamer` will be used.
+            post_output_audio_delay (float, optional): The delay in seconds to post the output audio.
+                Defaults to 0.5 seconds.
+
+        Raises:
+            ValueError: If the `input_streamers` or `output_streamers` is an empty list.
+            ValueError: If the `post_output_audio_delay` is not greater than 0.
+            Exception: If the conversation fails to process.
+        """

gllm_inference/realtime_chat/input_streamer/__init__.pyi

@@ -0,0 +1,4 @@
+from gllm_inference.realtime_chat.input_streamer.keyboard_input_streamer import KeyboardInputStreamer as KeyboardInputStreamer
+from gllm_inference.realtime_chat.input_streamer.linux_mic_input_streamer import LinuxMicInputStreamer as LinuxMicInputStreamer
+
+__all__ = ['KeyboardInputStreamer', 'LinuxMicInputStreamer']

gllm_inference/realtime_chat/input_streamer/input_streamer.pyi

@@ -0,0 +1,36 @@
+import abc
+import asyncio
+from abc import ABC, abstractmethod
+from pydantic import BaseModel as BaseModel
+
+class BaseInputStreamer(ABC, metaclass=abc.ABCMeta):
+    """[BETA] A base class for input streamers.
+
+    Attributes:
+        state (BaseModel | None): The state of the input streamer.
+        input_queue (asyncio.Queue | None): The queue to put the input events.
+    """
+    state: BaseModel | None
+    input_queue: asyncio.Queue | None
+    async def initialize(self, state: BaseModel, input_queue: asyncio.Queue) -> None:
+        """Initializes the input streamer.
+
+        Args:
+            input_queue (asyncio.Queue): The queue to put the input events.
+            state (BaseModel): The state of the input streamer.
+        """
+    @abstractmethod
+    async def stream_input(self) -> None:
+        """Streams the input from a certain source.
+
+        This method must be implemented by subclasses to define the logic for streaming the input.
+
+        Raises:
+            NotImplementedError: If the method is not implemented in a subclass.
+        """
+    async def close(self) -> None:
+        """Closes the input streamer.
+
+        This method is used to close the input streamer.
+        It is used to clean up the input streamer.
+        """

gllm_inference/realtime_chat/input_streamer/keyboard_input_streamer.pyi

@@ -0,0 +1,27 @@
+import asyncio
+from _typeshed import Incomplete
+from gllm_inference.realtime_chat.input_streamer.input_streamer import BaseInputStreamer as BaseInputStreamer
+
+DEFAULT_QUIT_CMD: str
+
+class KeyboardInputStreamer(BaseInputStreamer):
+    """[BETA] A keyboard input streamer that reads the input text from the keyboard.
+
+    Attributes:
+        state (BaseModel): The state of the input streamer.
+        input_queue (asyncio.Queue): The queue to put the input events.
+        quit_cmd (str): The command to quit the conversation.
+    """
+    record_process: asyncio.subprocess.Process | None
+    quit_cmd: Incomplete
+    def __init__(self, quit_cmd: str = ...) -> None:
+        """Initializes the KeyboardInputStreamer.
+
+        Args:
+            quit_cmd (str, optional): The command to quit the conversation. Defaults to DEFAULT_QUIT_CMD.
+        """
+    async def stream_input(self) -> None:
+        """Streams the input from the keyboard.
+
+        This method is used to stream the input text from the keyboard to the input queue.
+        """

gllm_inference/realtime_chat/input_streamer/linux_mic_input_streamer.pyi

@@ -0,0 +1,36 @@
+import asyncio
+from _typeshed import Incomplete
+from gllm_inference.realtime_chat.input_streamer.input_streamer import BaseInputStreamer as BaseInputStreamer
+
+SEND_SAMPLE_RATE: int
+CHANNELS: int
+RECORD_CMD: Incomplete
+CHUNK_DURATION: float
+CHUNK_SIZE: Incomplete
+
+class LinuxMicInputStreamer(BaseInputStreamer):
+    """[BETA] A Linux microphone input streamer that reads the input audio from the microphone.
+
+    Attributes:
+        state (BaseModel): The state of the input streamer.
+        input_queue (asyncio.Queue): The queue to put the input events.
+        record_process (asyncio.subprocess.Process | None): The process to record the input audio.
+    """
+    record_process: asyncio.subprocess.Process | None
+    def __init__(self) -> None:
+        """Initializes the LinuxMicInputStreamer.
+
+        Raises:
+            OSError: If the current system is not Linux.
+        """
+    async def stream_input(self) -> None:
+        """Streams the input audio from the Linux system microphone.
+
+        This method is used to stream the recorded input audio from the Linux system microphone to the input queue.
+        """
+    async def close(self) -> None:
+        """Closes the LinuxMicInputStreamer.
+
+        This method is used to close the LinuxMicInputStreamer.
+        It is used to clean up the recording process.
+        """

gllm_inference/realtime_chat/output_streamer/__init__.pyi

@@ -0,0 +1,4 @@
+from gllm_inference.realtime_chat.output_streamer.console_output_streamer import ConsoleOutputStreamer as ConsoleOutputStreamer
+from gllm_inference.realtime_chat.output_streamer.linux_speaker_output_streamer import LinuxSpeakerOutputStreamer as LinuxSpeakerOutputStreamer
+
+__all__ = ['ConsoleOutputStreamer', 'LinuxSpeakerOutputStreamer']

gllm_inference/realtime_chat/output_streamer/console_output_streamer.pyi

@@ -0,0 +1,21 @@
+from gllm_inference.realtime_chat.output_streamer.output_streamer import BaseOutputStreamer as BaseOutputStreamer
+from typing import Any
+
+USER_HEADER: str
+ASSISTANT_HEADER: str
+FOOTER: str
+
+class ConsoleOutputStreamer(BaseOutputStreamer):
+    """[BETA] A console output streamer that prints the output to the console.
+
+    Attributes:
+        state (BaseModel): The state of the output streamer.
+    """
+    async def handle(self, data: dict[str, Any]) -> None:
+        """Handles the output events.
+
+        This method is used to handle the text output events and print them to the console.
+
+        Args:
+            data (dict[str, Any]): The output events.
+        """

gllm_inference/realtime_chat/output_streamer/linux_speaker_output_streamer.pyi

@@ -0,0 +1,42 @@
+import asyncio
+from _typeshed import Incomplete
+from gllm_inference.realtime_chat.output_streamer.output_streamer import BaseOutputStreamer as BaseOutputStreamer
+from pydantic import BaseModel as BaseModel
+from typing import Any
+
+PLAY_AUDIO_SAMPLE_RATE: int
+CHANNELS: int
+PLAY_CMD: Incomplete
+OUTPUT_AUDIO_DELAY: float
+
+class LinuxSpeakerOutputStreamer(BaseOutputStreamer):
+    """[BETA] A Linux speaker output streamer that plays the output audio through the speakers.
+
+    Attributes:
+        state (BaseModel): The state of the output streamer.
+        play_process (asyncio.subprocess.Process | None): The process to play the output audio.
+    """
+    play_process: asyncio.subprocess.Process | None
+    async def initialize(self, state: BaseModel) -> None:
+        """Initializes the LinuxSpeakerOutputStreamer.
+
+        Args:
+            state (BaseModel): The state of the output streamer.
+
+        Raises:
+            OSError: If the current system is not Linux.
+        """
+    async def handle(self, data: dict[str, Any]) -> None:
+        """Handles the output events.
+
+        This method is used to handle the audio output events and play them through the Linux system speakers.
+
+        Args:
+            data (dict[str, Any]): The output events.
+        """
+    async def close(self) -> None:
+        """Closes the LinuxSpeakerOutputStreamer.
+
+        This method is used to close the LinuxSpeakerOutputStreamer.
+        It is used to clean up playing process.
+        """

gllm_inference/realtime_chat/output_streamer/output_streamer.pyi

@@ -0,0 +1,33 @@
+import abc
+from abc import ABC, abstractmethod
+from pydantic import BaseModel as BaseModel
+from typing import Any
+
+class BaseOutputStreamer(ABC, metaclass=abc.ABCMeta):
+    """[BETA] A base class for output streamers.
+
+    Attributes:
+        state (BaseModel | None): The state of the output streamer.
+    """
+    state: BaseModel | None
+    async def initialize(self, state: BaseModel) -> None:
+        """Initializes the output streamer.
+
+        Args:
+            state (BaseModel): The state of the output streamer.
+        """
+    @abstractmethod
+    async def handle(self, data: dict[str, Any]) -> None:
+        """Handles output events streamed from the model.
+
+        This method must be implemented by subclasses to define the logic for handling the output events.
+
+        Raises:
+            NotImplementedError: If the method is not implemented in a subclass.
+        """
+    async def close(self) -> None:
+        """Closes the output streamer.
+
+        This method is used to close the output streamer.
+        It is used to clean up the output streamer.
+        """

gllm_inference/realtime_chat/realtime_chat.pyi

@@ -0,0 +1,28 @@
+import abc
+from abc import ABC, abstractmethod
+from gllm_inference.realtime_chat.input_streamer.input_streamer import BaseInputStreamer as BaseInputStreamer
+from gllm_inference.realtime_chat.output_streamer.output_streamer import BaseOutputStreamer as BaseOutputStreamer
+
+class BaseRealtimeChat(ABC, metaclass=abc.ABCMeta):
+    """[BETA] A base class for realtime chat modules.
+
+    The `BaseRealtimeChat` class provides a framework for processing real-time conversations.
+    """
+    def __init__(self) -> None:
+        """Initializes a new instance of the BaseRealtimeChat class."""
+    @abstractmethod
+    async def start(self, input_streamers: list[BaseInputStreamer] | None = None, output_streamers: list[BaseOutputStreamer] | None = None) -> None:
+        """Starts the real-time conversation using the provided input and output streamers.
+
+        This abstract method must be implemented by subclasses to define the logic
+        for starting the real-time conversation.
+
+        Args:
+            input_streamers (list[BaseInputStreamer] | None, optional): The input streamers to use.
+                Defaults to None.
+            output_streamers (list[BaseOutputStreamer] | None, optional): The output streamers to use.
+                Defaults to None.
+
+        Raises:
+            NotImplementedError: If the method is not implemented in a subclass.
+        """

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
@@ -121,6 +122,11 @@ import xai_sdk.proto.v5
 import xai_sdk.proto.v5.chat_pb2
 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
+import google.genai.live
 import gllm_core.utils.logger_manager
 import mimetypes
 import uuid

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: gllm-inference-binary
-Version: 0.5.34
+Version: 0.5.36
 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