videosdk-plugins-openai 0.0.4__tar.gz → 0.0.6__tar.gz

{videosdk_plugins_openai-0.0.4 → videosdk_plugins_openai-0.0.6}/.gitignore

@@ -7,3 +7,4 @@ __pycache__
 .env.local
 test_env/
 dist/
+.DS_Store

{videosdk_plugins_openai-0.0.4 → videosdk_plugins_openai-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: videosdk-plugins-openai
-Version: 0.0.4
+Version: 0.0.6
 Summary: VideoSDK Agent Framework plugin for OpenAI services
 Author: videosdk
 Keywords: ai,audio,openai,video,videosdk
@@ -12,7 +12,7 @@ Classifier: Topic :: Multimedia :: Video
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.11
 Requires-Dist: openai[realtime]>=1.68.2
-Requires-Dist: videosdk-agents>=0.0.6
+Requires-Dist: videosdk-agents>=0.0.9
 Description-Content-Type: text/markdown
 
 VideoSDK OpenAI Plugin

{videosdk_plugins_openai-0.0.4 → videosdk_plugins_openai-0.0.6}/pyproject.toml

@@ -20,7 +20,7 @@ classifiers = [
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
 ]
 dependencies = [
-    "videosdk-agents>=0.0.6",
+    "videosdk-agents>=0.0.9",
     "openai[realtime]>=1.68.2",
 ]
 

videosdk_plugins_openai-0.0.6/videosdk/plugins/openai/__init__.py

@@ -0,0 +1,12 @@
+from .realtime_api import OpenAIRealtime, OpenAIRealtimeConfig
+from .llm import OpenAILLM
+from .stt import OpenAISTT
+from .tts import OpenAITTS
+
+__all__ = [
+    'OpenAIRealtime',
+    'OpenAIRealtimeConfig',
+    'OpenAILLM',
+    'OpenAISTT',
+    'OpenAITTS',
+]

videosdk_plugins_openai-0.0.6/videosdk/plugins/openai/llm.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import os
+from typing import Any, AsyncIterator
+import json
+
+import httpx
+import openai
+from videosdk.agents import LLM, LLMResponse, ChatContext, ChatRole, ChatMessage, FunctionCall, FunctionCallOutput, ToolChoice, FunctionTool, is_function_tool, build_openai_schema
+
+class OpenAILLM(LLM):
+    
+    def __init__(
+        self,
+        *,
+        model: str = "gpt-4o",
+        api_key: str | None = None,
+        base_url: str | None = None,
+        temperature: float = 0.7,
+        tool_choice: ToolChoice = "auto",
+        max_completion_tokens: int | None = None,
+    ) -> None:
+        super().__init__()
+        self.api_key = api_key or os.getenv("OPENAI_API_KEY")
+        if not self.api_key:
+            raise ValueError("OpenAI API key must be provided either through api_key parameter or OPENAI_API_KEY environment variable")
+        
+        self.model = model
+        self.temperature = temperature
+        self.tool_choice = tool_choice
+        self.max_completion_tokens = max_completion_tokens
+        
+        self._client = openai.AsyncOpenAI(
+            api_key=self.api_key,
+            base_url=base_url or None,
+            max_retries=0,
+            http_client=httpx.AsyncClient(
+                timeout=httpx.Timeout(connect=15.0, read=5.0, write=5.0, pool=5.0),
+                follow_redirects=True,
+                limits=httpx.Limits(
+                    max_connections=50,
+                    max_keepalive_connections=50,
+                    keepalive_expiry=120,
+                ),
+            ),
+        )
+
+    async def chat(
+        self,
+        messages: ChatContext,
+        tools: list[FunctionTool] | None = None,
+        **kwargs: Any
+    ) -> AsyncIterator[LLMResponse]:
+        """
+        Implement chat functionality using OpenAI's chat completion API
+        
+        Args:
+            messages: ChatContext containing conversation history
+            tools: Optional list of function tools available to the model
+            **kwargs: Additional arguments passed to the OpenAI API
+            
+        Yields:
+            LLMResponse objects containing the model's responses
+        """
+        completion_params = {
+            "model": self.model,
+            "messages": [
+                {
+                    "role": msg.role.value,
+                    "content": msg.content,
+                    **({"name": msg.name} if hasattr(msg, 'name') else {})
+                } if isinstance(msg, ChatMessage) else
+                {
+                    "role": "assistant",
+                    "content": None,
+                    "function_call": {
+                        "name": msg.name,
+                        "arguments": msg.arguments
+                    }
+                } if isinstance(msg, FunctionCall) else
+                {
+                    "role": "function",
+                    "name": msg.name,
+                    "content": msg.output
+                } if isinstance(msg, FunctionCallOutput) else None
+                for msg in messages.items
+                if msg is not None 
+            ],
+            "temperature": self.temperature,
+            "stream": True,
+            "max_tokens": self.max_completion_tokens,
+        }
+
+        if tools:
+            formatted_tools = []
+            for tool in tools:
+                if not is_function_tool(tool):
+                    continue
+                try:
+                    tool_schema = build_openai_schema(tool)
+                    formatted_tools.append(tool_schema)
+                except Exception as e:
+                    print(f"Failed to format tool {tool}: {e}")
+                    continue
+            
+            if formatted_tools:
+                completion_params["functions"] = formatted_tools
+                completion_params["function_call"] = self.tool_choice
+
+        completion_params.update(kwargs)
+        try:
+            response_stream = await self._client.chat.completions.create(**completion_params)
+            current_content = ""
+            current_function_call = None
+
+            async for chunk in response_stream:
+                if not chunk.choices:
+                    continue
+                    
+                delta = chunk.choices[0].delta
+                if delta.function_call:
+                    if current_function_call is None:
+                        current_function_call = {
+                            "name": delta.function_call.name or "",
+                            "arguments": delta.function_call.arguments or ""
+                        }
+                    else:
+                        if delta.function_call.name:
+                            current_function_call["name"] += delta.function_call.name
+                        if delta.function_call.arguments:
+                            current_function_call["arguments"] += delta.function_call.arguments
+                elif current_function_call is not None:  
+                    try:
+                        args = json.loads(current_function_call["arguments"])
+                        current_function_call["arguments"] = args
+                    except json.JSONDecodeError:
+                        print(f"Failed to parse function arguments: {current_function_call['arguments']}")
+                        current_function_call["arguments"] = {}
+                    
+                    yield LLMResponse(
+                        content="",
+                        role=ChatRole.ASSISTANT,
+                        metadata={"function_call": current_function_call}
+                    )
+                    current_function_call = None
+                
+                elif delta.content is not None:
+                    current_content += delta.content
+                    yield LLMResponse(
+                        content=current_content,
+                        role=ChatRole.ASSISTANT
+                    )
+
+        except Exception as e:
+            self.emit("error", e)
+            raise
+
+    async def aclose(self) -> None:
+        """Cleanup resources by closing the HTTP client"""
+        if self._client:
+            await self._client.close() 

{videosdk_plugins_openai-0.0.4 → videosdk_plugins_openai-0.0.6}/videosdk/plugins/openai/realtime_api.py

@@ -10,6 +10,8 @@ from dotenv import load_dotenv
 import uuid
 import base64
 import aiohttp
+import numpy as np
+from scipy import signal
 import traceback
 from videosdk.agents import (
     FunctionTool,
@@ -18,15 +20,14 @@ from videosdk.agents import (
     build_openai_schema,
     CustomAudioStreamTrack,
     ToolChoice,
-    RealtimeBaseModel
+    RealtimeBaseModel,
+    Agent
 )
 
 load_dotenv()
 from openai.types.beta.realtime.session import InputAudioTranscription, TurnDetection
 
 OPENAI_BASE_URL = "https://api.openai.com/v1"
-SAMPLE_RATE = 24000
-NUM_CHANNELS = 1
 
 DEFAULT_TEMPERATURE = 0.8
 DEFAULT_TURN_DETECTION = TurnDetection(
@@ -44,7 +45,8 @@ DEFAULT_TOOL_CHOICE = "auto"
 
 OpenAIEventTypes = Literal[
     "instructions_updated",
-    "tools_updated"
+    "tools_updated",
+    "text_response"
 ]
 DEFAULT_VOICE = "alloy"
 DEFAULT_INPUT_AUDIO_FORMAT = "pcm16"
@@ -128,8 +130,17 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
         self.audio_track: Optional[CustomAudioStreamTrack] = None
         self._formatted_tools: Optional[List[Dict[str, Any]]] = None
         self.config: OpenAIRealtimeConfig = config or OpenAIRealtimeConfig()
-        self.on("instructions_updated", self._handle_instructions_updated)
-        self.on("tools_updated", self._handle_tools_updated) 
+        # global_event_emitter.on("instructions_updated", self._handle_instructions_updated)
+        # global_event_emitter.on("tools_updated", self._handle_tools_updated)
+        
+        self.input_sample_rate = 48000
+        self.target_sample_rate = 16000
+    
+    def set_agent(self, agent: Agent) -> None:
+        self._instructions = agent.instructions
+        self._tools = agent.tools
+        self.tools_formatted = self._format_tools_for_session(self._tools)
+        self._formatted_tools = self.tools_formatted
     
     async def connect(self) -> None:
         headers = {"Agent": "VideoSDK Agents"}
@@ -144,7 +155,10 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
         
     async def handle_audio_input(self, audio_data: bytes) -> None:
         """Handle incoming audio data from the user"""
-        if self._session and not self._closing:
+        if self._session and not self._closing and "audio" in self.config.modalities:
+            audio_data = np.frombuffer(audio_data, dtype=np.int16)
+            audio_data = signal.resample(audio_data, int(len(audio_data) * self.target_sample_rate / self.input_sample_rate))
+            audio_data = audio_data.astype(np.int16).tobytes()
             base64_audio_data = base64.b64encode(audio_data).decode("utf-8")
             audio_event = {
                 "type": "input_audio_buffer.append",
@@ -299,17 +313,23 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
             
             elif event_type == "conversation.item.input_audio_transcription.completed":
                 await self._handle_input_audio_transcription_completed(data)
+                
+            elif event_type == "response.text.done":
+                await self._handle_text_done(data)
 
         except Exception as e:
             self.emit_error(f"Error handling event {event_type}: {str(e)}")
 
     async def _handle_speech_started(self, data: dict) -> None:
         """Handle speech detection start"""
-        await self.interrupt()
-        self.audio_track.interrupt()
+        if "audio" in self.config.modalities:
+            await self.interrupt()
+            if self.audio_track:
+                self.audio_track.interrupt()
 
     async def _handle_speech_stopped(self, data: dict) -> None:
         """Handle speech detection end"""
+        pass
 
     async def _handle_response_created(self, data: dict) -> None:
         """Handle initial response creation"""
@@ -365,6 +385,9 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
 
     async def _handle_audio_delta(self, data: dict) -> None:
         """Handle audio chunk"""
+        if "audio" not in self.config.modalities:
+            return
+            
         try:
             base64_audio_data = base64.b64decode(data.get("delta"))
             if base64_audio_data:
@@ -448,31 +471,45 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
         if not self._session:
             return
 
+        # Conditionally set turn detection and audio transcription based on modalities
+        turn_detection = None
+        input_audio_transcription = None
+        
+        if "audio" in self.config.modalities:
+            turn_detection = self.config.turn_detection.model_dump(
+                by_alias=True,
+                exclude_unset=True,
+                exclude_defaults=True,
+            ) if self.config.turn_detection else None
+            input_audio_transcription = self.config.input_audio_transcription.model_dump(
+                by_alias=True,
+                exclude_unset=True,
+                exclude_defaults=True,
+            ) if self.config.input_audio_transcription else None
+
         session_update = {
             "type": "session.update",
             "session": {
                 "model": self.model,
-                "voice": self.config.voice,
-                "instructions": self._instructions or  "You are a helpful voice assistant that can answer questions and help with tasks.",
+                "instructions": self._instructions or "You are a helpful assistant that can answer questions and help with tasks.",
                 "temperature": self.config.temperature,
-                "turn_detection": self.config.turn_detection.model_dump(
-                    by_alias=True,
-                    exclude_unset=True,
-                    exclude_defaults=True,
-                ),
-                "input_audio_transcription": self.config.input_audio_transcription.model_dump(
-                    by_alias=True,
-                    exclude_unset=True,
-                    exclude_defaults=True,
-                ),
                 "tool_choice": self.config.tool_choice,
                 "tools": self._formatted_tools or [],
                 "modalities": self.config.modalities,
-                "input_audio_format": DEFAULT_INPUT_AUDIO_FORMAT,
-                "output_audio_format": DEFAULT_OUTPUT_AUDIO_FORMAT,
                 "max_response_output_tokens": "inf"
             }
         }
+        
+        # Only add audio-related configurations if audio modality is enabled
+        if "audio" in self.config.modalities:
+            session_update["session"]["voice"] = self.config.voice
+            session_update["session"]["input_audio_format"] = DEFAULT_INPUT_AUDIO_FORMAT
+            session_update["session"]["output_audio_format"] = DEFAULT_OUTPUT_AUDIO_FORMAT
+            if turn_detection:
+                session_update["session"]["turn_detection"] = turn_detection
+            if input_audio_transcription:
+                session_update["session"]["input_audio_transcription"] = input_audio_transcription
+        
         # Send the event
         await self.send_event(session_update)
 
@@ -521,4 +558,33 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
         tools = data.get("tools", [])
         self._tools = tools
         self.tools_formatted = self._format_tools_for_session(tools)
-        self._formatted_tools = self.tools_formatted
+        self._formatted_tools = self.tools_formatted
+
+    async def send_text_message(self, message: str) -> None:
+        """Send a text message to the OpenAI realtime API"""
+        if not self._session:
+            raise RuntimeError("No active WebSocket session")
+            
+        await self.send_event({
+            "type": "conversation.item.create",
+            "item": {
+                "type": "message",
+                "role": "user",
+                "content": [
+                    {
+                        "type": "input_text",
+                        "text": message
+                    }
+                ]
+            }
+        })
+        await self.create_response()
+
+    async def _handle_text_done(self, data: dict) -> None:
+        """Handle text response completion"""
+        try:
+            text_content = data.get("text", "")
+            if text_content:
+                self.emit("text_response", {"text": text_content, "type": "done"})
+        except Exception as e:
+            print(f"[ERROR] Error handling text done: {e}")

videosdk_plugins_openai-0.0.6/videosdk/plugins/openai/stt.py

@@ -0,0 +1,260 @@
+from __future__ import annotations
+
+import asyncio
+import base64
+import os
+from typing import Any, Optional
+from urllib.parse import urlencode
+from scipy import signal
+import aiohttp
+import httpx
+import openai
+import numpy as np
+from videosdk.agents import STT as BaseSTT, STTResponse, SpeechEventType, SpeechData, global_event_emitter
+
+class OpenAISTT(BaseSTT):
+    def __init__(
+        self,
+        *,
+        api_key: str,
+        model: str = "whisper-1",
+        base_url: str | None = None,
+        prompt: str | None = None,
+        language: str = "en",
+        turn_detection: dict | None = None,
+    ) -> None:
+        super().__init__()
+        
+        self.api_key = api_key or os.getenv("OPENAI_API_KEY")
+        if not self.api_key:
+            raise ValueError("OpenAI API key must be provided either through api_key parameter or OPENAI_API_KEY environment variable")
+        
+        self.model = model
+        self.language = language
+        self.prompt = prompt
+        self.turn_detection = turn_detection or {
+            "type": "server_vad",
+            "threshold": 0.5,
+            "prefix_padding_ms": 300,
+            "silence_duration_ms": 500,
+        }
+        
+        self.client = openai.AsyncClient(
+            max_retries=0,
+            api_key=api_key,
+            base_url=base_url or None,
+            http_client=httpx.AsyncClient(
+                timeout=httpx.Timeout(connect=15.0, read=5.0, write=5.0, pool=5.0),
+                follow_redirects=True,
+                limits=httpx.Limits(
+                    max_connections=50,
+                    max_keepalive_connections=50,
+                    keepalive_expiry=120,
+                ),
+            ),
+        )
+        
+        self._session: Optional[aiohttp.ClientSession] = None
+        self._ws: Optional[aiohttp.ClientWebSocketResponse] = None
+        self._ws_task: Optional[asyncio.Task] = None
+        self._current_text = ""
+        self._last_interim_at = 0
+    
+        self.input_sample_rate = 48000
+        self.target_sample_rate = 16000
+        
+    async def process_audio(
+        self,
+        audio_frames: bytes,
+        language: Optional[str] = None,
+        **kwargs: Any
+    ) -> None:
+        """Process audio frames and send to OpenAI's Realtime API"""
+        
+        if not self._ws:
+            await self._connect_ws()
+            self._ws_task = asyncio.create_task(self._listen_for_responses())
+            
+        try:
+            audio_data = np.frombuffer(audio_frames, dtype=np.int16)
+            audio_data = signal.resample(audio_data, int(len(audio_data) * self.target_sample_rate / self.input_sample_rate))
+            audio_data = audio_data.astype(np.int16).tobytes()
+            audio_data = base64.b64encode(audio_data).decode("utf-8")
+            message = {
+                "type": "input_audio_buffer.append",
+                "audio": audio_data,
+            }
+            await self._ws.send_json(message)
+        except Exception as e:
+            print(f"Error in process_audio: {str(e)}")
+            self.emit("error", str(e))
+            if self._ws:
+                await self._ws.close()
+                self._ws = None
+                if self._ws_task:
+                    self._ws_task.cancel()
+                    self._ws_task = None
+
+    async def _listen_for_responses(self) -> None:
+        """Background task to listen for WebSocket responses"""
+        if not self._ws:
+            return
+            
+        try:
+            async for msg in self._ws:
+                if msg.type == aiohttp.WSMsgType.TEXT:
+                    data = msg.json()
+                    responses = self._handle_ws_message(data)
+                    for response in responses:
+                        if self._transcript_callback:
+                            await self._transcript_callback(response)
+                elif msg.type == aiohttp.WSMsgType.ERROR:
+                    error = f"WebSocket error: {self._ws.exception()}"
+                    print(error)
+                    self.emit("error", error)
+                    break
+                elif msg.type == aiohttp.WSMsgType.CLOSED:
+                    print("WebSocket connection closed")
+                    break
+        except Exception as e:
+            error = f"Error in WebSocket listener: {str(e)}"
+            print(error)
+            self.emit("error", error)
+        finally:
+            if self._ws:
+                await self._ws.close()
+                self._ws = None
+                
+    async def _connect_ws(self) -> None:
+        """Establish WebSocket connection with OpenAI's Realtime API"""
+        
+        if not self._session:
+            self._session = aiohttp.ClientSession()
+            
+        config = {
+            "type": "transcription_session.update",
+            "session": {
+                "input_audio_format": "pcm16",
+                "input_audio_transcription": {
+                    "model": self.model,
+                    "prompt": self.prompt or "",
+                    "language": self.language if self.language else None,
+                },
+                "turn_detection": self.turn_detection,
+                "input_audio_noise_reduction": {
+                    "type": "near_field"
+                },
+                "include": ["item.input_audio_transcription.logprobs"]
+            }
+        }
+        
+        query_params = {
+            "intent": "transcription",
+        }
+        headers = {
+            "User-Agent": "VideoSDK",
+            "Authorization": f"Bearer {self.api_key}",
+            "OpenAI-Beta": "realtime=v1",
+        }
+        
+        base_url = str(self.client.base_url).rstrip('/')
+        ws_url = f"{base_url}/realtime?{urlencode(query_params)}"
+        if ws_url.startswith("http"):
+            ws_url = ws_url.replace("http", "ws", 1)
+
+        try:
+            self._ws = await self._session.ws_connect(ws_url, headers=headers)
+            
+            initial_response = await self._ws.receive_json()
+            
+            if initial_response.get("type") != "transcription_session.created":
+                raise Exception(f"Expected session creation, got: {initial_response}")
+            
+            await self._ws.send_json(config)
+            
+            update_response = await self._ws.receive_json()
+            
+            if update_response.get("type") != "transcription_session.updated":
+                raise Exception(f"Configuration update failed: {update_response}")
+            
+        except Exception as e:
+            print(f"Error connecting to WebSocket: {str(e)}")
+            if self._ws:
+                await self._ws.close()
+                self._ws = None
+            raise
+        
+    def _handle_ws_message(self, msg: dict) -> list[STTResponse]:
+        """Handle incoming WebSocket messages and generate STT responses"""
+        responses = []
+        
+        try:
+            msg_type = msg.get("type")
+            if msg_type == "conversation.item.input_audio_transcription.delta":
+                delta = msg.get("delta", "")
+                if delta:
+                    self._current_text += delta
+                    current_time = asyncio.get_event_loop().time()
+                    
+                    if current_time - self._last_interim_at > 0.5:
+                        responses.append(STTResponse(
+                            event_type=SpeechEventType.INTERIM,
+                            data=SpeechData(
+                                text=self._current_text,
+                                language=self.language,
+                            ),
+                            metadata={"model": self.model}
+                        ))
+                        self._last_interim_at = current_time
+                        
+            elif msg_type == "conversation.item.input_audio_transcription.completed":
+                transcript = msg.get("transcript", "")
+                if transcript:
+                    responses.append(STTResponse(
+                        event_type=SpeechEventType.FINAL,
+                        data=SpeechData(
+                            text=transcript,
+                            language=self.language,
+                        ),
+                        metadata={"model": self.model}
+                    ))
+                    self._current_text = ""
+            
+            elif msg_type == "input_audio_buffer.speech_started":
+                global_event_emitter.emit("speech_started")
+            
+            elif msg_type == "input_audio_buffer.speech_stopped":
+                global_event_emitter.emit("speech_stopped")
+                
+        except Exception as e:
+            print(f"Error handling WebSocket message: {str(e)}")
+        
+        return responses
+
+    async def aclose(self) -> None:
+        """Cleanup resources"""
+        if self._ws_task:
+            self._ws_task.cancel()
+            try:
+                await self._ws_task
+            except asyncio.CancelledError:
+                pass
+            self._ws_task = None
+            
+        if self._ws:
+            await self._ws.close()
+            self._ws = None
+            
+        if self._session:
+            await self._session.close()
+            self._session = None
+            
+        await self.client.close()
+
+    async def _ensure_ws_connection(self):
+        """Ensure WebSocket is connected, reconnect if necessary"""
+        if not self._ws or self._ws.closed:
+            await self._connect_ws()
+
+
+

videosdk_plugins_openai-0.0.6/videosdk/plugins/openai/tts.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from typing import Any, AsyncIterator, Literal, Optional, Union
+import httpx
+import os
+import openai
+
+from videosdk.agents import TTS
+
+OPENAI_TTS_SAMPLE_RATE = 24000
+OPENAI_TTS_CHANNELS = 1
+
+DEFAULT_MODEL = "gpt-4o-mini-tts"
+DEFAULT_VOICE = "ash"
+_RESPONSE_FORMATS = Union[Literal["mp3", "opus", "aac", "flac", "wav", "pcm"], str]
+
+class OpenAITTS(TTS):
+    def __init__(
+        self,
+        *,
+        model: str = DEFAULT_MODEL,
+        voice: str = DEFAULT_VOICE,
+        speed: float = 1.0,
+        instructions: str | None = None,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        response_format: str = "pcm"
+    ) -> None:
+        super().__init__(sample_rate=OPENAI_TTS_SAMPLE_RATE, num_channels=OPENAI_TTS_CHANNELS)
+        
+        self.model = model
+        self.voice = voice
+        self.speed = speed
+        self.instructions = instructions
+        self.audio_track = None
+        self.loop = None
+        self.response_format = response_format
+        
+        self.api_key = api_key or os.getenv("OPENAI_API_KEY")
+        if not self.api_key:
+            raise ValueError("OpenAI API key must be provided either through api_key parameter or OPENAI_API_KEY environment variable")
+        
+        self._client = openai.AsyncClient(
+            max_retries=0,
+            api_key=self.api_key,
+            base_url=base_url or None,
+            http_client=httpx.AsyncClient(
+                timeout=httpx.Timeout(connect=15.0, read=5.0, write=5.0, pool=5.0),
+                follow_redirects=True,
+                limits=httpx.Limits(
+                    max_connections=50,
+                    max_keepalive_connections=50,
+                    keepalive_expiry=120,
+                ),
+            ),
+        )
+    
+    async def synthesize(
+        self,
+        text: AsyncIterator[str] | str,
+        voice_id: Optional[str] = None,
+        **kwargs: Any
+    ) -> None:
+        """
+        Convert text to speech using OpenAI's TTS API and stream to audio track
+        
+        Args:
+            text: Text to convert to speech
+            voice_id: Optional voice override
+            **kwargs: Additional provider-specific arguments
+        """
+        try:
+            if isinstance(text, AsyncIterator):
+                full_text = ""
+                async for chunk in text:
+                    full_text += chunk
+            else:
+                full_text = text
+
+            if not self.audio_track or not self.loop:
+                self.emit("error", "Audio track or event loop not set")
+                return
+
+            async with self._client.audio.speech.with_streaming_response.create(
+                model=self.model,
+                voice=voice_id or self.voice,
+                input=full_text,
+                speed=self.speed,
+                response_format=self.response_format,
+                **({"instructions": self.instructions} if self.instructions else {})
+            ) as response:
+                async for chunk in response.iter_bytes():
+                    if chunk:
+                        self.loop.create_task(self.audio_track.add_new_bytes(chunk))
+
+        except openai.APIError as e:
+            self.emit("error", str(e))
+        except Exception as e:
+            self.emit("error", f"TTS synthesis failed: {str(e)}")
+
+    async def aclose(self) -> None:
+        """Cleanup resources"""
+        await self._client.close()
+        await super().aclose()
+
+    async def interrupt(self) -> None:
+        """Interrupt the TTS process"""
+        if self.audio_track:
+            self.audio_track.interrupt()

videosdk_plugins_openai-0.0.6/videosdk/plugins/openai/version.py

@@ -0,0 +1 @@
+__version__ = "0.0.6"

videosdk_plugins_openai-0.0.4/videosdk/plugins/openai/__init__.py

@@ -1,6 +0,0 @@
-from .realtime_api import OpenAIRealtime, OpenAIRealtimeConfig
-
-__all__ = [
-    'OpenAIRealtime',
-    'OpenAIRealtimeConfig'
-]

videosdk_plugins_openai-0.0.4/videosdk/plugins/openai/version.py

@@ -1 +0,0 @@
-__version__ = "0.0.4"