Realtime providers

Author: akavi

examples/guardrails_wrapper/guardrails.py

@@ -213,7 +213,7 @@ async def _check_guardrails(self, text: str) -> GuardrailCheckResult:
 
         try:
             response_text = ""
-            stream = self._guardrail_llm.chat(messages, tools=None)
+            stream = await self._guardrail_llm.chat(messages, tools=None)
             async with stream:
                 async for chunk in stream:
                     if chunk.text:

line/llm_agent/__init__.py

@@ -16,6 +16,9 @@
 # LLM Agent
 from line.llm_agent.llm_agent import LlmAgent
 
+# Provider facade
+from line.llm_agent.provider import LlmProvider
+
 # Tool type decorators
 from line.llm_agent.tools.decorators import handoff_tool, loopback_tool, passthrough_tool
 
@@ -38,6 +41,8 @@
     "History",
     # LLM Agent
     "LlmAgent",
+    # Provider
+    "LlmProvider",
     # Configuration
     "LlmConfig",
     "FALLBACK_SYSTEM_PROMPT",

line/llm_agent/llm_agent.py

@@ -22,7 +22,6 @@
     Union,
 )
 
-from litellm import get_supported_openai_params
 from loguru import logger
 
 from line.agent import AgentCallable, TurnEnv
@@ -43,7 +42,7 @@
 )
 from line.llm_agent.config import LlmConfig, _merge_configs, _normalize_config
 from line.llm_agent.history import _HISTORY_EVENT_TYPES, History
-from line.llm_agent.provider import LLMProvider, Message, ToolCall
+from line.llm_agent.provider import LlmProvider, Message, ToolCall
 from line.llm_agent.tools.decorators import loopback_tool
 from line.llm_agent.tools.system import EndCallTool, WebSearchTool
 from line.llm_agent.tools.utils import FunctionTool, ToolEnv, ToolType, construct_function_tool
@@ -75,19 +74,9 @@ def __init__(
     ):
         if not api_key:
             raise ValueError("Missing API key in LLmAgent initialization")
-        supported_params = get_supported_openai_params(model=model)
-        if supported_params is None:
-            raise ValueError(
-                f"Model {model} is not supported. See https://models.litellm.ai/ for supported models."
-            )
 
         # Resolve the base config to insert default values for any _UNSET sentinels.
         effective_config = _normalize_config(config or LlmConfig())
-        if effective_config.reasoning_effort is not None and "reasoning_effort" not in supported_params:
-            raise ValueError(
-                f"Model {model} does not support reasoning_effort. "
-                "Remove reasoning_effort from your LlmConfig or use a model that supports it."
-            )
 
         self._model = model
         self._api_key = api_key
@@ -96,10 +85,10 @@ def __init__(
 
         self._tools: List[ToolSpec] = list(tools or [])
 
-        self._llm = LLMProvider(
-            model=self._model,
-            api_key=self._api_key,
-            config=self._config,
+        self._llm = LlmProvider(
+            model=model,
+            api_key=api_key,
+            config=effective_config,
         )
 
         self._introduction_sent = False
@@ -186,11 +175,18 @@ async def process(
 
         # Handle CallStarted
         if isinstance(event, CallStarted):
+            warmup_task = asyncio.create_task(
+                self._llm.warmup(config=effective_config)
+            )
             if effective_config.introduction and not self._introduction_sent:
                 output = AgentSendText(text=effective_config.introduction)
                 self.history._append_local(output)
                 self._introduction_sent = True
                 yield output
+            try:
+                await warmup_task
+            except Exception as e:
+                logger.warning(f"Provider warmup failed: {e}")
             return
 
         # Handle CallEnded
@@ -347,7 +343,7 @@ async def _generate_response(
             first_token_logged = False
             first_agent_text_logged = False
 
-            stream = self._llm.chat(
+            stream = await self._llm.chat(
                 messages,
                 tools if tools else None,
                 config=config,

line/llm_agent/provider.py

@@ -52,7 +52,7 @@ class Message:
     name: Optional[str] = None
 
 
-class LLMProvider:
+class _HttpProvider:
     """
     LLM provider using LiteLLM for unified multi-provider access.
 
@@ -85,7 +85,7 @@ def __init__(
             except Exception:
                 pass
 
-    def chat(
+    async def chat(
         self,
         messages: List[Message],
         tools: Optional[List[FunctionTool]] = None,
@@ -101,7 +101,7 @@ def chat(
                 are used for sampling/model parameters and system prompt instead
                 of the config passed at init time.
         """
-        cfg = config or self._config
+        cfg = _normalize_config(config) if config else self._config
         llm_messages = self._build_messages(messages, cfg)
 
         llm_kwargs: Dict[str, Any] = {
@@ -150,7 +150,7 @@ def _build_messages(
         self, messages: List[Message], config: Optional[LlmConfig] = None
     ) -> List[Dict[str, Any]]:
         """Convert Message objects to LiteLLM format."""
-        cfg = config or self._config
+        cfg = _normalize_config(config) if config else self._config
         result = []
 
         if cfg.system_prompt:
@@ -189,6 +189,10 @@ def _build_messages(
             result.append(llm_msg)
         return result
 
+    async def warmup(self, config=None):
+        """No-op for stateless HTTP provider."""
+        pass
+
     async def aclose(self) -> None:
         """Close the provider (no-op for LiteLLM)."""
         pass
@@ -271,3 +275,52 @@ async def __aiter__(self) -> AsyncIterator[StreamChunk]:
                 tool_calls=list(tool_calls.values()) if tool_calls else [],
                 is_final=finish_reason is not None,
             )
+
+
+# ---------------------------------------------------------------------------
+# Unified facade
+# ---------------------------------------------------------------------------
+
+
+def _is_realtime_model(model: str) -> bool:
+    """Check if a model name indicates an OpenAI Realtime model."""
+    return "realtime" in model.lower()
+
+
+def _is_websocket_model(model: str) -> bool:
+    """Check if a model should use the WebSocket (Responses API) backend."""
+    lower = model.lower()
+    return lower.startswith("gpt-5.2") or lower.startswith("gpt5.2")
+
+
+class LlmProvider:
+    """Unified LLM provider facade.
+
+    Selects the appropriate backend (HTTP/LiteLLM, Realtime WS, or Responses WS)
+    based on the model name, and delegates all calls to it.
+    """
+
+    def __init__(self, model, api_key=None, config=None):
+        if _is_realtime_model(model):
+            from line.llm_agent.realtime_provider import RealtimeProvider
+
+            self._backend = RealtimeProvider(model=model, api_key=api_key, config=config)
+        elif _is_websocket_model(model):
+            from line.llm_agent.websocket_provider import WebSocketProvider
+
+            self._backend = WebSocketProvider(model=model, api_key=api_key, config=config)
+        else:
+            self._backend = _HttpProvider(model=model, api_key=api_key, config=config)
+
+    async def chat(self, messages, tools=None, config=None, **kwargs):
+        return await self._backend.chat(messages, tools, config=config, **kwargs)
+
+    async def warmup(self, config=None):
+        await self._backend.warmup(config)
+
+    async def aclose(self):
+        await self._backend.aclose()
+
+
+# Backward-compat alias — existing scripts and examples import LLMProvider directly.
+LLMProvider = _HttpProvider