ag2 0.9.1a1__py3-none-any.whl → 0.9.1.post0__py3-none-any.whl

autogen/agentchat/realtime/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0

autogen/agentchat/realtime/experimental/__init__.py

@@ -0,0 +1,20 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .audio_adapters import TwilioAudioAdapter, WebSocketAudioAdapter
+from .audio_observer import AudioObserver
+from .function_observer import FunctionObserver
+from .realtime_agent import RealtimeAgent
+from .realtime_observer import RealtimeObserver
+from .realtime_swarm import register_swarm
+
+__all__ = [
+    "AudioObserver",
+    "FunctionObserver",
+    "RealtimeAgent",
+    "RealtimeObserver",
+    "TwilioAudioAdapter",
+    "WebSocketAudioAdapter",
+    "register_swarm",
+]

autogen/agentchat/realtime/experimental/audio_adapters/__init__.py

@@ -0,0 +1,8 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .twilio_audio_adapter import TwilioAudioAdapter
+from .websocket_audio_adapter import WebSocketAudioAdapter
+
+__all__ = ["TwilioAudioAdapter", "WebSocketAudioAdapter"]

autogen/agentchat/realtime/experimental/audio_adapters/twilio_audio_adapter.py

@@ -0,0 +1,148 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import base64
+import json
+from logging import Logger
+from typing import TYPE_CHECKING, Optional
+
+from .....doc_utils import export_module
+from ..realtime_events import AudioDelta, RealtimeEvent, SpeechStarted
+from ..realtime_observer import RealtimeObserver
+
+if TYPE_CHECKING:
+    from ..websockets import WebSocketProtocol as WebSocket
+
+
+LOG_EVENT_TYPES = [
+    "error",
+    "response.content.done",
+    "rate_limits.updated",
+    "response.done",
+    "input_audio_buffer.committed",
+    "input_audio_buffer.speech_stopped",
+    "input_audio_buffer.speech_started",
+    "session.created",
+]
+SHOW_TIMING_MATH = False
+
+
+@export_module("autogen.agentchat.realtime.experimental")
+class TwilioAudioAdapter(RealtimeObserver):
+    """Adapter for streaming audio from Twilio to OpenAI Realtime API and vice versa."""
+
+    def __init__(self, websocket: "WebSocket", *, logger: Optional[Logger] = None):
+        """Adapter for streaming audio from Twilio to OpenAI Realtime API and vice versa.
+
+        Args:
+            websocket: the websocket connection to the Twilio service
+            logger: the logger to use for logging events
+        """
+        super().__init__(logger=logger)
+        self.websocket = websocket
+
+        # Connection specific state
+        self.stream_sid = None
+        self.latest_media_timestamp = 0
+        self.last_assistant_item: Optional[str] = None
+        self.mark_queue: list[str] = []
+        self.response_start_timestamp_twilio: Optional[int] = None
+
+    async def on_event(self, event: RealtimeEvent) -> None:
+        """Receive events from the OpenAI Realtime API, send audio back to Twilio."""
+        logger = self.logger
+
+        if isinstance(event, AudioDelta):
+            audio_payload = base64.b64encode(base64.b64decode(event.delta)).decode("utf-8")
+            audio_delta = {"event": "media", "streamSid": self.stream_sid, "media": {"payload": audio_payload}}
+            await self.websocket.send_json(audio_delta)
+
+            if self.response_start_timestamp_twilio is None:
+                self.response_start_timestamp_twilio = self.latest_media_timestamp
+                if SHOW_TIMING_MATH:
+                    logger.info(f"Setting start timestamp for new response: {self.response_start_timestamp_twilio}ms")
+
+            # Update last_assistant_item safely
+            if event.item_id:
+                self.last_assistant_item = event.item_id
+
+            await self.send_mark()
+
+        # Trigger an interruption. Your use case might work better using `input_audio_buffer.speech_stopped`, or combining the two.
+        if isinstance(event, SpeechStarted):
+            logger.info("Speech start detected.")
+            if self.last_assistant_item:
+                logger.info(f"Interrupting response with id: {self.last_assistant_item}")
+                await self.handle_speech_started_event()
+
+    async def handle_speech_started_event(self) -> None:
+        """Handle interruption when the caller's speech starts."""
+        logger = self.logger
+
+        logger.info("Handling speech started event.")
+        if self.mark_queue and self.response_start_timestamp_twilio is not None:
+            elapsed_time = self.latest_media_timestamp - self.response_start_timestamp_twilio
+            if SHOW_TIMING_MATH:
+                logger.info(
+                    f"Calculating elapsed time for truncation: {self.latest_media_timestamp} - {self.response_start_timestamp_twilio} = {elapsed_time}ms"
+                )
+
+            if self.last_assistant_item:
+                if SHOW_TIMING_MATH:
+                    logger.info(f"Truncating item with ID: {self.last_assistant_item}, Truncated at: {elapsed_time}ms")
+
+                await self.realtime_client.truncate_audio(
+                    audio_end_ms=elapsed_time,
+                    content_index=0,
+                    item_id=self.last_assistant_item,
+                )
+
+            await self.websocket.send_json({"event": "clear", "streamSid": self.stream_sid})
+
+            self.mark_queue.clear()
+            self.last_assistant_item = None
+            self.response_start_timestamp_twilio = None
+
+    async def send_mark(self) -> None:
+        """Send a mark of audio interruption to the Twilio websocket."""
+        if self.stream_sid:
+            mark_event = {"event": "mark", "streamSid": self.stream_sid, "mark": {"name": "responsePart"}}
+            await self.websocket.send_json(mark_event)
+            self.mark_queue.append("responsePart")
+
+    async def run_loop(self) -> None:
+        """Run the adapter loop."""
+        logger = self.logger
+
+        async for message in self.websocket.iter_text():
+            try:
+                data = json.loads(message)
+                if data["event"] == "media":
+                    self.latest_media_timestamp = int(data["media"]["timestamp"])
+                    await self.realtime_client.send_audio(audio=data["media"]["payload"])
+                elif data["event"] == "start":
+                    self.stream_sid = data["start"]["streamSid"]
+                    logger.info(f"Incoming stream has started {self.stream_sid}")
+                    self.response_start_timestamp_twilio = None
+                    self.latest_media_timestamp = 0
+                    self.last_assistant_item = None
+                elif data["event"] == "mark":
+                    if self.mark_queue:
+                        self.mark_queue.pop(0)
+            except Exception as e:
+                logger.warning(f"Error processing Twilio message: {e}", stack_info=True)
+
+    async def initialize_session(self) -> None:
+        """Control initial session with OpenAI."""
+        session_update = {
+            "input_audio_format": "g711_ulaw",
+            "output_audio_format": "g711_ulaw",
+        }
+        await self.realtime_client.session_update(session_update)
+
+
+if TYPE_CHECKING:
+
+    def twilio_audio_adapter(websocket: "WebSocket") -> RealtimeObserver:
+        return TwilioAudioAdapter(websocket)

autogen/agentchat/realtime/experimental/audio_adapters/websocket_audio_adapter.py

@@ -0,0 +1,139 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import base64
+import json
+from logging import Logger
+from typing import TYPE_CHECKING, Optional
+
+from .....doc_utils import export_module
+from ..realtime_events import AudioDelta, RealtimeEvent, SpeechStarted
+from ..realtime_observer import RealtimeObserver
+
+if TYPE_CHECKING:
+    from ..websockets import WebSocketProtocol as WebSocket
+
+LOG_EVENT_TYPES = [
+    "error",
+    "response.content.done",
+    "rate_limits.updated",
+    "response.done",
+    "input_audio_buffer.committed",
+    "input_audio_buffer.speech_stopped",
+    "input_audio_buffer.speech_started",
+    "session.created",
+]
+SHOW_TIMING_MATH = False
+
+
+@export_module("autogen.agentchat.realtime.experimental")
+class WebSocketAudioAdapter(RealtimeObserver):
+    def __init__(self, websocket: "WebSocket", *, logger: Optional[Logger] = None) -> None:
+        """Observer for handling function calls from the OpenAI Realtime API.
+
+        Args:
+            websocket (WebSocket): The websocket connection.
+            logger (Logger): The logger for the observer.
+        """
+        super().__init__(logger=logger)
+        self.websocket = websocket
+
+        # Connection specific state
+        self.stream_sid = None
+        self.latest_media_timestamp = 0
+        self.last_assistant_item: Optional[str] = None
+        self.mark_queue: list[str] = []
+        self.response_start_timestamp_socket: Optional[int] = None
+
+    async def on_event(self, event: RealtimeEvent) -> None:
+        """Receive events from the OpenAI Realtime API, send audio back to websocket."""
+        logger = self.logger
+
+        if isinstance(event, AudioDelta):
+            audio_payload = base64.b64encode(base64.b64decode(event.delta)).decode("utf-8")
+            audio_delta = {"event": "media", "streamSid": self.stream_sid, "media": {"payload": audio_payload}}
+            await self.websocket.send_json(audio_delta)
+
+            if self.response_start_timestamp_socket is None:
+                self.response_start_timestamp_socket = self.latest_media_timestamp
+                if SHOW_TIMING_MATH:
+                    logger.info(f"Setting start timestamp for new response: {self.response_start_timestamp_socket}ms")
+
+            # Update last_assistant_item safely
+            if event.item_id:
+                self.last_assistant_item = event.item_id
+
+            await self.send_mark()
+
+        # Trigger an interruption. Your use case might work better using `input_audio_buffer.speech_stopped`, or combining the two.
+        if isinstance(event, SpeechStarted):
+            logger.info("Speech start detected.")
+            if self.last_assistant_item:
+                logger.info(f"Interrupting response with id: {self.last_assistant_item}")
+                await self.handle_speech_started_event()
+
+    async def handle_speech_started_event(self) -> None:
+        """Handle interruption when the caller's speech starts."""
+        logger = self.logger
+        logger.info("Handling speech started event.")
+        if self.mark_queue and self.response_start_timestamp_socket is not None:
+            elapsed_time = self.latest_media_timestamp - self.response_start_timestamp_socket
+            if SHOW_TIMING_MATH:
+                logger.info(
+                    f"Calculating elapsed time for truncation: {self.latest_media_timestamp} - {self.response_start_timestamp_socket} = {elapsed_time}ms"
+                )
+
+            if self.last_assistant_item:
+                if SHOW_TIMING_MATH:
+                    logger.info(f"Truncating item with ID: {self.last_assistant_item}, Truncated at: {elapsed_time}ms")
+
+                await self.realtime_client.truncate_audio(
+                    audio_end_ms=elapsed_time,
+                    content_index=0,
+                    item_id=self.last_assistant_item,
+                )
+
+            await self.websocket.send_json({"event": "clear", "streamSid": self.stream_sid})
+
+            self.mark_queue.clear()
+            self.last_assistant_item = None
+            self.response_start_timestamp_socket = None
+
+    async def send_mark(self) -> None:
+        if self.stream_sid:
+            mark_event = {"event": "mark", "streamSid": self.stream_sid, "mark": {"name": "responsePart"}}
+            await self.websocket.send_json(mark_event)
+            self.mark_queue.append("responsePart")
+
+    async def initialize_session(self) -> None:
+        """Control initial session with OpenAI."""
+        session_update = {"input_audio_format": "pcm16", "output_audio_format": "pcm16"}
+        await self.realtime_client.session_update(session_update)
+
+    async def run_loop(self) -> None:
+        """Reads data from websocket and sends it to the RealtimeClient."""
+        logger = self.logger
+        async for message in self.websocket.iter_text():
+            try:
+                data = json.loads(message)
+                if data["event"] == "media":
+                    self.latest_media_timestamp = int(data["media"]["timestamp"])
+                    await self.realtime_client.send_audio(audio=data["media"]["payload"])
+                elif data["event"] == "start":
+                    self.stream_sid = data["start"]["streamSid"]
+                    logger.info(f"Incoming stream has started {self.stream_sid}")
+                    self.response_start_timestamp_socket = None
+                    self.latest_media_timestamp = 0
+                    self.last_assistant_item = None
+                elif data["event"] == "mark":
+                    if self.mark_queue:
+                        self.mark_queue.pop(0)
+            except Exception as e:
+                logger.warning(f"Failed to process message: {e}", stack_info=True)
+
+
+if TYPE_CHECKING:
+
+    def websocket_audio_adapter(websocket: "WebSocket") -> RealtimeObserver:
+        return WebSocketAudioAdapter(websocket)

autogen/agentchat/realtime/experimental/audio_observer.py

@@ -0,0 +1,42 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import TYPE_CHECKING, Optional
+
+from ....doc_utils import export_module
+from .realtime_events import InputAudioBufferDelta, RealtimeEvent
+from .realtime_observer import RealtimeObserver
+
+if TYPE_CHECKING:
+    from logging import Logger
+
+
+@export_module("autogen.agentchat.realtime.experimental")
+class AudioObserver(RealtimeObserver):
+    """Observer for user voice input"""
+
+    def __init__(self, *, logger: Optional["Logger"] = None) -> None:
+        """Observer for user voice input"""
+        super().__init__(logger=logger)
+
+    async def on_event(self, event: RealtimeEvent) -> None:
+        """Observe voice input events from the Realtime.
+
+        Args:
+            event (dict[str, Any]): The event from the OpenAI Realtime API.
+        """
+        if isinstance(event, InputAudioBufferDelta):
+            self.logger.info("Received audio buffer delta")
+
+    async def initialize_session(self) -> None:
+        """No need to initialize session from this observer"""
+        pass
+
+    async def run_loop(self) -> None:
+        """Run the observer loop."""
+        pass
+
+
+if TYPE_CHECKING:
+    function_observer: RealtimeObserver = AudioObserver()

autogen/agentchat/realtime/experimental/clients/__init__.py

@@ -0,0 +1,15 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .gemini.client import GeminiRealtimeClient
+from .oai.base_client import OpenAIRealtimeClient
+from .realtime_client import RealtimeClientProtocol, Role, get_client
+
+__all__ = [
+    "GeminiRealtimeClient",
+    "OpenAIRealtimeClient",
+    "RealtimeClientProtocol",
+    "Role",
+    "get_client",
+]

autogen/agentchat/realtime/experimental/clients/gemini/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .client import GeminiRealtimeClient
+
+__all__ = ["GeminiRealtimeClient"]

autogen/agentchat/realtime/experimental/clients/gemini/client.py

@@ -0,0 +1,274 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from logging import Logger, getLogger
+from typing import TYPE_CHECKING, Any, Callable, Optional, Union
+
+from ......doc_utils import export_module
+from ......import_utils import optional_import_block, require_optional_import
+from ......llm_config import LLMConfig
+from ...realtime_events import AudioDelta, FunctionCall, RealtimeEvent, SessionCreated
+from ..realtime_client import RealtimeClientBase, Role, register_realtime_client
+
+with optional_import_block():
+    from websockets.asyncio.client import connect
+
+
+if TYPE_CHECKING:
+    from websockets.asyncio.client import ClientConnection
+
+    from ..realtime_client import RealtimeClientProtocol
+
+__all__ = ["GeminiRealtimeClient"]
+
+global_logger = getLogger(__name__)
+
+
+HOST = "generativelanguage.googleapis.com"
+API_VERSION = "v1alpha"
+
+
+@register_realtime_client()
+@require_optional_import("websockets", "gemini", except_for=["get_factory", "__init__"])
+@export_module("autogen.agentchat.realtime.experimental.clients")
+class GeminiRealtimeClient(RealtimeClientBase):
+    """(Experimental) Client for Gemini Realtime API."""
+
+    def __init__(
+        self,
+        *,
+        llm_config: Union[LLMConfig, dict[str, Any]],
+        logger: Optional[Logger] = None,
+    ) -> None:
+        """(Experimental) Client for Gemini Realtime API.
+
+        Args:
+            llm_config: The config for the client.
+            logger: The logger for the client.
+        """
+        super().__init__()
+        self._llm_config = llm_config
+        self._logger = logger
+
+        self._connection: Optional["ClientConnection"] = None
+        config = llm_config["config_list"][0]
+
+        self._model: str = config["model"]
+        self._voice = config.get("voice", "charon")
+        self._temperature: float = config.get("temperature", 0.8)  # type: ignore[union-attr]
+
+        self._response_modality = "AUDIO"
+
+        self._api_key = config.get("api_key", None)
+        # todo: add test with base_url just to make sure it works
+        self._base_url: str = config.get(
+            "base_url",
+            f"wss://{HOST}/ws/google.ai.generativelanguage.{API_VERSION}.GenerativeService.BidiGenerateContent?key={self._api_key}",
+        )
+        self._final_config: dict[str, Any] = {}
+        self._pending_session_updates: dict[str, Any] = {}
+        self._is_reading_events = False
+
+    @property
+    def logger(self) -> Logger:
+        """Get the logger for the Gemini Realtime API."""
+        return self._logger or global_logger
+
+    @property
+    def connection(self) -> "ClientConnection":
+        """Get the Gemini WebSocket connection."""
+        if self._connection is None:
+            raise RuntimeError("Gemini WebSocket is not initialized")
+        return self._connection
+
+    async def send_function_result(self, call_id: str, result: str) -> None:
+        """Send the result of a function call to the Gemini Realtime API.
+
+        Args:
+            call_id (str): The ID of the function call.
+            result (str): The result of the function call.
+        """
+        msg = {
+            "tool_response": {"function_responses": [{"id": call_id, "response": {"result": {"string_value": result}}}]}
+        }
+        if self._is_reading_events:
+            await self.connection.send(json.dumps(msg))
+
+    async def send_text(self, *, role: Role, text: str, turn_complete: bool = True) -> None:
+        """Send a text message to the Gemini Realtime API.
+
+        Args:
+            role: The role of the message.
+            text: The text of the message.
+            turn_complete: A flag indicating if the turn is complete.
+        """
+        msg = {
+            "client_content": {
+                "turn_complete": turn_complete,
+                "turns": [{"role": role, "parts": [{"text": text}]}],
+            }
+        }
+        if self._is_reading_events:
+            await self.connection.send(json.dumps(msg))
+
+    async def send_audio(self, audio: str) -> None:
+        """Send audio to the Gemini Realtime API.
+
+        Args:
+            audio (str): The audio to send.
+        """
+        msg = {
+            "realtime_input": {
+                "media_chunks": [
+                    {
+                        "data": audio,
+                        "mime_type": "audio/pcm",
+                    }
+                ]
+            }
+        }
+        await self.queue_input_audio_buffer_delta(audio)
+        if self._is_reading_events:
+            await self.connection.send(json.dumps(msg))
+
+    async def truncate_audio(self, audio_end_ms: int, content_index: int, item_id: str) -> None:
+        self.logger.info("This is not natively supported by Gemini Realtime API.")
+        pass
+
+    async def _initialize_session(self) -> None:
+        """Initialize the session with the Gemini Realtime API."""
+        session_config = {
+            "setup": {
+                "system_instruction": {
+                    "role": "system",
+                    "parts": [{"text": self._pending_session_updates.get("instructions", "")}],
+                },
+                "model": f"models/{self._model}",
+                "tools": [
+                    {
+                        "function_declarations": [
+                            {
+                                "name": tool_schema["name"],
+                                "description": tool_schema["description"],
+                                "parameters": tool_schema["parameters"],
+                            }
+                            for tool_schema in self._pending_session_updates.get("tools", [])
+                        ]
+                    },
+                ],
+                "generation_config": {
+                    "response_modalities": [self._response_modality],
+                    "speech_config": {"voiceConfig": {"prebuiltVoiceConfig": {"voiceName": self._voice}}},
+                    "temperature": self._temperature,
+                },
+            }
+        }
+
+        self.logger.info(f"Sending session update: {session_config}")
+        await self.connection.send(json.dumps(session_config))
+
+    async def session_update(self, session_options: dict[str, Any]) -> None:
+        """Record session updates to be applied when the connection is established.
+
+        Args:
+            session_options (dict[str, Any]): The session options to update.
+        """
+        if self._is_reading_events:
+            self.logger.warning("Is reading events. Session update will be ignored.")
+        else:
+            self._pending_session_updates.update(session_options)
+
+    @asynccontextmanager
+    async def connect(self) -> AsyncGenerator[None, None]:
+        """Connect to the Gemini Realtime API."""
+        try:
+            async with connect(
+                self._base_url, additional_headers={"Content-Type": "application/json"}
+            ) as self._connection:
+                yield
+        finally:
+            self._connection = None
+
+    async def read_events(self) -> AsyncGenerator[RealtimeEvent, None]:
+        """Read Events from the Gemini Realtime Client"""
+        if self._connection is None:
+            raise RuntimeError("Client is not connected, call connect() first.")
+        await self._initialize_session()
+
+        self._is_reading_events = True
+
+        async for event in self._read_events():
+            yield event
+
+    async def _read_from_connection(self) -> AsyncGenerator[RealtimeEvent, None]:
+        """Read messages from the Gemini Realtime connection."""
+        async for raw_message in self.connection:
+            message = raw_message.decode("ascii") if isinstance(raw_message, bytes) else raw_message
+            events = self._parse_message(json.loads(message))
+            for event in events:
+                yield event
+
+    def _parse_message(self, response: dict[str, Any]) -> list[RealtimeEvent]:
+        """Parse a message from the Gemini Realtime API.
+
+        Args:
+            response (dict[str, Any]): The response to parse.
+
+        Returns:
+            list[RealtimeEvent]: The parsed events.
+        """
+        if "serverContent" in response and "modelTurn" in response["serverContent"]:
+            try:
+                b64data = response["serverContent"]["modelTurn"]["parts"][0]["inlineData"].pop("data")
+                return [
+                    AudioDelta(
+                        delta=b64data,
+                        item_id=None,
+                        raw_message=response,
+                    )
+                ]
+            except KeyError:
+                return []
+        elif "toolCall" in response:
+            return [
+                FunctionCall(
+                    raw_message=response,
+                    call_id=call["id"],
+                    name=call["name"],
+                    arguments=call["args"],
+                )
+                for call in response["toolCall"]["functionCalls"]
+            ]
+        elif "setupComplete" in response:
+            return [
+                SessionCreated(raw_message=response),
+            ]
+        else:
+            return [RealtimeEvent(raw_message=response)]
+
+    @classmethod
+    def get_factory(
+        cls, llm_config: Union[LLMConfig, dict[str, Any]], logger: Logger, **kwargs: Any
+    ) -> Optional[Callable[[], "RealtimeClientProtocol"]]:
+        """Create a Realtime API client.
+
+        Args:
+            llm_config: The LLM config for the client.
+            logger: The logger for the client.
+            **kwargs: Additional arguments.
+
+        Returns:
+            RealtimeClientProtocol: The Realtime API client is returned if the model matches the pattern
+        """
+        if llm_config["config_list"][0].get("api_type") == "google" and list(kwargs.keys()) == []:
+            return lambda: GeminiRealtimeClient(llm_config=llm_config, logger=logger, **kwargs)
+        return None
+
+
+# needed for mypy to check if GeminiRealtimeClient implements RealtimeClientProtocol
+if TYPE_CHECKING:
+    _client: RealtimeClientProtocol = GeminiRealtimeClient(llm_config={})

autogen/agentchat/realtime/experimental/clients/oai/__init__.py

@@ -0,0 +1,8 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .base_client import OpenAIRealtimeClient
+from .rtc_client import OpenAIRealtimeWebRTCClient
+
+__all__ = ["OpenAIRealtimeClient", "OpenAIRealtimeWebRTCClient"]