videosdk-plugins-openai 0.0.26__tar.gz → 0.0.28__tar.gz

{videosdk_plugins_openai-0.0.26 → videosdk_plugins_openai-0.0.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: videosdk-plugins-openai
-Version: 0.0.26
+Version: 0.0.28
 Summary: VideoSDK Agent Framework plugin for OpenAI services
 Author: videosdk
 License-Expression: Apache-2.0
@@ -13,7 +13,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.26
+Requires-Dist: videosdk-agents>=0.0.28
 Description-Content-Type: text/markdown
 
 # VideoSDK OpenAI Plugin

{videosdk_plugins_openai-0.0.26 → videosdk_plugins_openai-0.0.28}/pyproject.toml

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

{videosdk_plugins_openai-0.0.26 → videosdk_plugins_openai-0.0.28}/videosdk/plugins/openai/llm.py

@@ -42,6 +42,7 @@ class OpenAILLM(LLM):
         self.temperature = temperature
         self.tool_choice = tool_choice
         self.max_completion_tokens = max_completion_tokens
+        self._cancelled = False
         
         self._client = openai.AsyncOpenAI(
             api_key=self.api_key,
@@ -75,6 +76,8 @@ class OpenAILLM(LLM):
         Yields:
             LLMResponse objects containing the model's responses
         """
+        self._cancelled = False
+        
         def _format_content(content: Union[str, List[ChatContent]]):
             if isinstance(content, str):
                 return content
@@ -139,14 +142,17 @@ class OpenAILLM(LLM):
             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 self._cancelled:
+                    break
+                
                 if not chunk.choices:
                     continue
                     
@@ -178,17 +184,22 @@ class OpenAILLM(LLM):
                     current_function_call = None
                 
                 elif delta.content is not None:
-                    current_content += delta.content
+                    current_content = delta.content
                     yield LLMResponse(
                         content=current_content,
                         role=ChatRole.ASSISTANT
                     )
 
         except Exception as e:
-            self.emit("error", e)
+            if not self._cancelled:
+                self.emit("error", e)
             raise
 
+    async def cancel_current_generation(self) -> None:
+        self._cancelled = True
+
     async def aclose(self) -> None:
         """Cleanup resources by closing the HTTP client"""
+        await self.cancel_current_generation()
         if self._client:
-            await self._client.close() 
+            await self._client.close()       

{videosdk_plugins_openai-0.0.26 → videosdk_plugins_openai-0.0.28}/videosdk/plugins/openai/realtime_api.py

@@ -22,7 +22,7 @@ from videosdk.agents import (
     ToolChoice,
     RealtimeBaseModel,
     global_event_emitter,
-    Agent
+    Agent,
 )
 from videosdk.agents import realtime_metrics_collector
 
@@ -46,19 +46,16 @@ DEFAULT_INPUT_AUDIO_TRANSCRIPTION = InputAudioTranscription(
 )
 DEFAULT_TOOL_CHOICE = "auto"
 
-OpenAIEventTypes = Literal[
-    "user_speech_started",
-    "text_response",
-    "error"
-]
+OpenAIEventTypes = Literal["user_speech_started", "text_response", "error"]
 DEFAULT_VOICE = "alloy"
 DEFAULT_INPUT_AUDIO_FORMAT = "pcm16"
 DEFAULT_OUTPUT_AUDIO_FORMAT = "pcm16"
 
+
 @dataclass
 class OpenAIRealtimeConfig:
     """Configuration for the OpenAI realtime API
-    
+
     Args:
         voice: Voice ID for audio output. Default is 'alloy'
         temperature: Controls randomness in response generation. Higher values (e.g. 0.8) make output more random,
@@ -75,23 +72,31 @@ class OpenAIRealtimeConfig:
         tool_choice: How tools should be selected ('auto' or 'none'). Default is 'auto'
         modalities: List of enabled response types ["text", "audio"]. Default includes both
     """
+
     voice: str = DEFAULT_VOICE
     temperature: float = DEFAULT_TEMPERATURE
-    turn_detection: TurnDetection | None = field(default_factory=lambda: DEFAULT_TURN_DETECTION)
-    input_audio_transcription: InputAudioTranscription | None = field(default_factory=lambda: DEFAULT_INPUT_AUDIO_TRANSCRIPTION)
+    turn_detection: TurnDetection | None = field(
+        default_factory=lambda: DEFAULT_TURN_DETECTION
+    )
+    input_audio_transcription: InputAudioTranscription | None = field(
+        default_factory=lambda: DEFAULT_INPUT_AUDIO_TRANSCRIPTION
+    )
     tool_choice: ToolChoice | None = DEFAULT_TOOL_CHOICE
     modalities: list[str] = field(default_factory=lambda: ["text", "audio"])
 
+
 @dataclass
 class OpenAISession:
     """Represents an OpenAI WebSocket session"""
+
     ws: aiohttp.ClientWebSocketResponse
     msg_queue: asyncio.Queue[Dict[str, Any]]
     tasks: list[asyncio.Task]
 
+
 class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
     """OpenAI's realtime model implementation."""
-    
+
     def __init__(
         self,
         *,
@@ -102,7 +107,7 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
     ) -> None:
         """
         Initialize OpenAI realtime model.
-        
+
         Args:
             model: The OpenAI model identifier to use (e.g. 'gpt-4', 'gpt-3.5-turbo')
             config: Optional configuration object for customizing model behavior. Contains settings for:
@@ -114,7 +119,7 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
                    - modalities: List of enabled modalities ('text', 'audio')
             api_key: OpenAI API key. If not provided, will attempt to read from OPENAI_API_KEY env var
             base_url: Base URL for OpenAI API. Defaults to 'https://api.openai.com/v1'
-        
+
         Raises:
             ValueError: If no API key is provided and none found in environment variables
         """
@@ -123,8 +128,13 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
         self.api_key = api_key or os.getenv("OPENAI_API_KEY")
         self.base_url = base_url or OPENAI_BASE_URL
         if not self.api_key:
-            self.emit("error", "OpenAI API key must be provided or set in OPENAI_API_KEY environment variable")
-            raise ValueError("OpenAI API key must be provided or set in OPENAI_API_KEY environment variable")
+            self.emit(
+                "error",
+                "OpenAI API key must be provided or set in OPENAI_API_KEY environment variable",
+            )
+            raise ValueError(
+                "OpenAI API key must be provided or set in OPENAI_API_KEY environment variable"
+            )
         self._http_session: Optional[aiohttp.ClientSession] = None
         self._session: Optional[OpenAISession] = None
         self._closing = False
@@ -137,34 +147,37 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
         self.input_sample_rate = 48000
         self.target_sample_rate = 16000
         self._agent_speaking = False
-    
+
     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"}
         headers["Authorization"] = f"Bearer {self.api_key}"
         headers["OpenAI-Beta"] = "realtime=v1"
-        
+
         url = self.process_base_url(self.base_url, self.model)
-        
+
         self._session = await self._create_session(url, headers)
         await self._handle_websocket(self._session)
         await self.send_first_session_update()
-        
+
     async def handle_audio_input(self, audio_data: bytes) -> None:
         """Handle incoming audio data from the user"""
         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 = 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",
-                "audio": base64_audio_data
+                "audio": base64_audio_data,
             }
             await self.send_event(audio_event)
 
@@ -176,58 +189,69 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
 
     async def _create_session(self, url: str, headers: dict) -> OpenAISession:
         """Create a new WebSocket session"""
-        
+
         http_session = await self._ensure_http_session()
-        ws = await http_session.ws_connect(url, headers=headers, autoping=True, heartbeat=10, autoclose=False, timeout=30)
+        ws = await http_session.ws_connect(
+            url,
+            headers=headers,
+            autoping=True,
+            heartbeat=10,
+            autoclose=False,
+            timeout=30,
+        )
         msg_queue: asyncio.Queue = asyncio.Queue()
         tasks: list[asyncio.Task] = []
-        
+
         self._closing = False
-        
+
         return OpenAISession(ws=ws, msg_queue=msg_queue, tasks=tasks)
-    
+
     async def send_message(self, message: str) -> None:
         """Send a message to the OpenAI realtime API"""
-        await self.send_event({
-            "type": "conversation.item.create",
-            "item": {
-                "type": "message",
-                "role": "assistant",
-                "content": [
-                    {
-                        "type": "text",
-                        "text": "Repeat the user's exact message back to them:" + message + "DO NOT ADD ANYTHING ELSE",
-                    }
-                ]
+        await self.send_event(
+            {
+                "type": "conversation.item.create",
+                "item": {
+                    "type": "message",
+                    "role": "assistant",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": "Repeat the user's exact message back to them:"
+                            + message
+                            + "DO NOT ADD ANYTHING ELSE",
+                        }
+                    ],
+                },
             }
-        })
+        )
         await self.create_response()
-        
+
     async def create_response(self) -> None:
         """Create a response to the OpenAI realtime API"""
         if not self._session:
             self.emit("error", "No active WebSocket session")
             raise RuntimeError("No active WebSocket session")
-            
+
         response_event = {
             "type": "response.create",
             "event_id": str(uuid.uuid4()),
             "response": {
-                "instructions": self._instructions, 
-                "metadata": {
-                    "client_event_id": str(uuid.uuid4()) 
-                }
-            }
+                "instructions": self._instructions,
+                "metadata": {"client_event_id": str(uuid.uuid4())},
+            },
         }
-        
+
         await self.send_event(response_event)
-    
+
     async def _handle_websocket(self, session: OpenAISession) -> None:
         """Start WebSocket send/receive tasks"""
-        session.tasks.extend([
-            asyncio.create_task(self._send_loop(session), name="send_loop"),
-            asyncio.create_task(self._receive_loop(session), name="receive_loop")
-        ])
+        session.tasks.extend(
+            [
+                asyncio.create_task(self._send_loop(session), name="send_loop"),
+                asyncio.create_task(self._receive_loop(session), name="receive_loop"),
+            ]
+        )
 
     async def _send_loop(self, session: OpenAISession) -> None:
         """Send messages from queue to WebSocket"""
@@ -248,7 +272,7 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
         try:
             while not self._closing:
                 msg = await session.ws.receive()
-                
+
                 if msg.type == aiohttp.WSMsgType.CLOSED:
                     self.emit("error", f"WebSocket closed with reason: {msg.extra}")
                     break
@@ -265,50 +289,50 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
     async def _handle_message(self, data: dict) -> None:
         """Handle incoming WebSocket messages"""
         try:
-            event_type = data.get('type')
+            event_type = data.get("type")
 
             if event_type == "input_audio_buffer.speech_started":
                 await self._handle_speech_started(data)
-            
+
             elif event_type == "input_audio_buffer.speech_stopped":
                 await self._handle_speech_stopped(data)
 
             elif event_type == "response.created":
                 await self._handle_response_created(data)
-                
+
             elif event_type == "response.output_item.added":
                 await self._handle_output_item_added(data)
-                
+
             elif event_type == "response.content_part.added":
                 await self._handle_content_part_added(data)
-                
+
             elif event_type == "response.text.delta":
                 await self._handle_text_delta(data)
 
             elif event_type == "response.audio.delta":
                 await self._handle_audio_delta(data)
-                
+
             elif event_type == "response.audio_transcript.delta":
                 await self._handle_audio_transcript_delta(data)
-                
+
             elif event_type == "response.done":
                 await self._handle_response_done(data)
 
             elif event_type == "error":
                 await self._handle_error(data)
-            
+
             elif event_type == "response.function_call_arguments.delta":
                 await self._handle_function_call_arguments_delta(data)
-            
+
             elif event_type == "response.function_call_arguments.done":
                 await self._handle_function_call_arguments_done(data)
-            
+
             elif event_type == "response.output_item.done":
                 await self._handle_output_item_done(data)
-            
+
             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)
 
@@ -334,15 +358,18 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
 
     async def _handle_output_item_added(self, data: dict) -> None:
         """Handle new output item addition"""
-    
+
     async def _handle_output_item_done(self, data: dict) -> None:
         """Handle output item done"""
         try:
             item = data.get("item", {})
-            if item.get("type") == "function_call" and item.get("status") == "completed":
+            if (
+                item.get("type") == "function_call"
+                and item.get("status") == "completed"
+            ):
                 name = item.get("name")
                 arguments = json.loads(item.get("arguments", "{}"))
-                
+
                 if name and self._tools:
                     for tool in self._tools:
                         tool_info = get_tool_info(tool)
@@ -350,28 +377,34 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
                             try:
                                 await realtime_metrics_collector.add_tool_call(name)
                                 result = await tool(**arguments)
-                                await self.send_event({
-                                    "type": "conversation.item.create",
-                                    "item": {
-                                        "type": "function_call_output",
-                                        "call_id": item.get("call_id"),
-                                        "output": json.dumps(result)
+                                await self.send_event(
+                                    {
+                                        "type": "conversation.item.create",
+                                        "item": {
+                                            "type": "function_call_output",
+                                            "call_id": item.get("call_id"),
+                                            "output": json.dumps(result),
+                                        },
                                     }
-                                })
-                                
-                                await self.send_event({
-                                    "type": "response.create",
-                                    "event_id": str(uuid.uuid4()),
-                                    "response": {
-                                        "instructions": self._instructions,
-                                        "metadata": {
-                                            "client_event_id": str(uuid.uuid4())
-                                        }
+                                )
+
+                                await self.send_event(
+                                    {
+                                        "type": "response.create",
+                                        "event_id": str(uuid.uuid4()),
+                                        "response": {
+                                            "instructions": self._instructions,
+                                            "metadata": {
+                                                "client_event_id": str(uuid.uuid4())
+                                            },
+                                        },
                                     }
-                                })
-                                
+                                )
+
                             except Exception as e:
-                                self.emit("error", f"Error executing function {name}: {e}")
+                                self.emit(
+                                    "error", f"Error executing function {name}: {e}"
+                                )
                             break
         except Exception as e:
             self.emit("error", f"Error handling output item done: {e}")
@@ -387,7 +420,7 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
         """Handle audio chunk"""
         if "audio" not in self.config.modalities:
             return
-            
+
         try:
             if not self._agent_speaking:
                 await realtime_metrics_collector.set_agent_speech_start()
@@ -395,18 +428,17 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
             base64_audio_data = base64.b64decode(data.get("delta"))
             if base64_audio_data:
                 if self.audio_track and self.loop:
-                    self.loop.create_task(self.audio_track.add_new_bytes(base64_audio_data))
+                    asyncio.create_task(
+                        self.audio_track.add_new_bytes(base64_audio_data)
+                    )
         except Exception as e:
             self.emit("error", f"Error handling audio delta: {e}")
             traceback.print_exc()
-    
+
     async def interrupt(self) -> None:
         """Interrupt the current response and flush audio"""
         if self._session and not self._closing:
-            cancel_event = {
-                "type": "response.cancel",
-                "event_id": str(uuid.uuid4())
-            }
+            cancel_event = {"type": "response.cancel", "event_id": str(uuid.uuid4())}
             await self.send_event(cancel_event)
             await realtime_metrics_collector.set_interrupted()
         if self.audio_track:
@@ -414,11 +446,11 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
         if self._agent_speaking:
             await realtime_metrics_collector.set_agent_speech_end(timeout=1.0)
             self._agent_speaking = False
-            
+
     async def _handle_audio_transcript_delta(self, data: dict) -> None:
         """Handle transcript chunk"""
         delta_content = data.get("delta", "")
-        if not hasattr(self, '_current_audio_transcript'):
+        if not hasattr(self, "_current_audio_transcript"):
             self._current_audio_transcript = ""
         self._current_audio_transcript += delta_content
 
@@ -428,25 +460,35 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
         if transcript:
             await realtime_metrics_collector.set_user_transcript(transcript)
             try:
-                self.emit("realtime_model_transcription", {
-                    "role": "user",
-                    "text": transcript,
-                    "is_final": True
-                })
+                self.emit(
+                    "realtime_model_transcription",
+                    {"role": "user", "text": transcript, "is_final": True},
+                )
             except Exception:
                 pass
 
     async def _handle_response_done(self, data: dict) -> None:
         """Handle response completion for agent transcript"""
-        if hasattr(self, '_current_audio_transcript') and self._current_audio_transcript:
-            await realtime_metrics_collector.set_agent_response(self._current_audio_transcript)
-            global_event_emitter.emit("text_response", {"text": self._current_audio_transcript, "type": "done"})
+        if (
+            hasattr(self, "_current_audio_transcript")
+            and self._current_audio_transcript
+        ):
+            await realtime_metrics_collector.set_agent_response(
+                self._current_audio_transcript
+            )
+            global_event_emitter.emit(
+                "text_response",
+                {"text": self._current_audio_transcript, "type": "done"},
+            )
             try:
-                self.emit("realtime_model_transcription", {
-                    "role": "agent",
-                    "text": self._current_audio_transcript,
-                    "is_final": True
-                })
+                self.emit(
+                    "realtime_model_transcription",
+                    {
+                        "role": "agent",
+                        "text": self._current_audio_transcript,
+                        "is_final": True,
+                    },
+                )
             except Exception:
                 pass
             self._current_audio_transcript = ""
@@ -465,11 +507,11 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
 
     async def _cleanup_session(self, session: OpenAISession) -> None:
         """Clean up session resources"""
-        if self._closing: 
+        if self._closing:
             return
-            
+
         self._closing = True
-        
+
         for task in session.tasks:
             if not task.done():
                 task.cancel()
@@ -483,7 +525,7 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
                 await session.ws.close()
             except Exception:
                 pass
-        
+
     async def send_event(self, event: Dict[str, Any]) -> None:
         """Send an event to the WebSocket"""
         if self._session and not self._closing:
@@ -493,15 +535,15 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
         """Cleanup all resources"""
         if self._closing:
             return
-            
+
         self._closing = True
-        
+
         if self._session:
             await self._cleanup_session(self._session)
-        
+
         if self._http_session and not self._http_session.closed:
             await self._http_session.close()
-            
+
     async def send_first_session_update(self) -> None:
         """Send initial session update with default values after connection"""
         if not self._session:
@@ -509,41 +551,54 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
 
         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
+            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,
-                "instructions": self._instructions or "You are a helpful 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,
                 "tool_choice": self.config.tool_choice,
                 "tools": self._formatted_tools or [],
                 "modalities": self.config.modalities,
-                "max_response_output_tokens": "inf"
-            }
+                "max_response_output_tokens": "inf",
+            },
         }
-        
+
         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
+            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
-        
+                session_update["session"][
+                    "input_audio_transcription"
+                ] = input_audio_transcription
+
         # Send the event
         await self.send_event(session_update)
 
@@ -560,27 +615,31 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
             path = parsed_url.path
 
         if "model" not in query_params:
-                query_params["model"] = [model]
+            query_params["model"] = [model]
 
         new_query = urlencode(query_params, doseq=True)
-        new_url = urlunparse((parsed_url.scheme, parsed_url.netloc, path, "", new_query, ""))
+        new_url = urlunparse(
+            (parsed_url.scheme, parsed_url.netloc, path, "", new_query, "")
+        )
 
         return new_url
 
-    def _format_tools_for_session(self, tools: List[FunctionTool]) -> List[Dict[str, Any]]:
+    def _format_tools_for_session(
+        self, tools: List[FunctionTool]
+    ) -> List[Dict[str, Any]]:
         """Format tools for OpenAI session update"""
         oai_tools = []
         for tool in tools:
             if not is_function_tool(tool):
                 continue
-                
+
             try:
                 tool_schema = build_openai_schema(tool)
                 oai_tools.append(tool_schema)
             except Exception as e:
                 self.emit("error", f"Failed to format tool {tool}: {e}")
                 continue
-                
+
         return oai_tools
 
     async def send_text_message(self, message: str) -> None:
@@ -588,19 +647,15 @@ class OpenAIRealtime(RealtimeBaseModel[OpenAIEventTypes]):
         if not self._session:
             self.emit("error", "No active WebSocket 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.send_event(
+            {
+                "type": "conversation.item.create",
+                "item": {
+                    "type": "message",
+                    "role": "user",
+                    "content": [{"type": "input_text", "text": message}],
+                },
             }
-        })
+        )
         await self.create_response()
-

{videosdk_plugins_openai-0.0.26 → videosdk_plugins_openai-0.0.28}/videosdk/plugins/openai/tts.py

@@ -6,14 +6,17 @@ import os
 import openai
 import asyncio
 
-from videosdk.agents import TTS
+from videosdk.agents import TTS, segment_text
 
 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]
+_RESPONSE_FORMATS = Union[Literal["mp3",
+                                  "opus", "aac", "flac", "wav", "pcm"], str]
+
+
 
 class OpenAITTS(TTS):
     def __init__(
@@ -25,10 +28,10 @@ class OpenAITTS(TTS):
         instructions: str | None = None,
         api_key: str | None = None,
         base_url: str | None = None,
-        response_format: str = "pcm"
+        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
@@ -37,17 +40,21 @@ class OpenAITTS(TTS):
         self.loop = None
         self.response_format = response_format
         self._first_chunk_sent = False
-        
+        self._current_synthesis_task: asyncio.Task | None = None
+        self._interrupted = False
+
         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")
-        
+            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),
+                timeout=httpx.Timeout(
+                    connect=15.0, read=5.0, write=5.0, pool=5.0),
                 follow_redirects=True,
                 limits=httpx.Limits(
                     max_connections=50,
@@ -60,71 +67,86 @@ class OpenAITTS(TTS):
     def reset_first_audio_tracking(self) -> None:
         """Reset the first audio tracking state for next TTS task"""
         self._first_chunk_sent = False
-    
+
     async def synthesize(
         self,
         text: AsyncIterator[str] | str,
         voice_id: Optional[str] = None,
-        **kwargs: Any
+        **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
 
+            self._interrupted = False
+
+            if isinstance(text, AsyncIterator):
+                async for segment in segment_text(text):
+                    if self._interrupted:
+                        break
+                    await self._synthesize_segment(segment, voice_id, **kwargs)
+            else:
+                if not self._interrupted:
+                    await self._synthesize_segment(text, voice_id, **kwargs)
+
+        except Exception as e:
+            self.emit("error", f"TTS synthesis failed: {str(e)}")
+
+    async def _synthesize_segment(self, text: str, voice_id: Optional[str] = None, **kwargs: Any) -> None:
+        """Synthesize a single text segment"""
+        if not text.strip() or self._interrupted:
+            return
+
+        try:
             audio_data = b""
             async with self._client.audio.speech.with_streaming_response.create(
                 model=self.model,
                 voice=voice_id or self.voice,
-                input=full_text,
+                input=text,
                 speed=self.speed,
                 response_format=self.response_format,
-                **({"instructions": self.instructions} if self.instructions else {})
+                **({"instructions": self.instructions} if self.instructions else {}),
             ) as response:
                 async for chunk in response.iter_bytes():
+                    if self._interrupted:
+                        break
                     if chunk:
                         audio_data += chunk
 
-            if audio_data:
+            if audio_data and not self._interrupted:
                 await self._stream_audio_chunks(audio_data)
 
-        except openai.APIError as e:
-            self.emit("error", str(e))
         except Exception as e:
-            self.emit("error", f"TTS synthesis failed: {str(e)}")
+            if not self._interrupted:
+                self.emit("error", f"Segment synthesis failed: {str(e)}")
 
     async def _stream_audio_chunks(self, audio_bytes: bytes) -> None:
         """Stream audio data in chunks for smooth playback"""
-        chunk_size = int(OPENAI_TTS_SAMPLE_RATE * OPENAI_TTS_CHANNELS * 2 * 20 / 1000) 
-        
+        chunk_size = int(OPENAI_TTS_SAMPLE_RATE *
+                         OPENAI_TTS_CHANNELS * 2 * 20 / 1000)
+
         for i in range(0, len(audio_bytes), chunk_size):
             chunk = audio_bytes[i:i + chunk_size]
-            
+
             if len(chunk) < chunk_size and len(chunk) > 0:
                 padding_needed = chunk_size - len(chunk)
                 chunk += b'\x00' * padding_needed
-            
+
             if len(chunk) == chunk_size:
                 if not self._first_chunk_sent and self._first_audio_callback:
                     self._first_chunk_sent = True
                     await self._first_audio_callback()
-                
-                self.loop.create_task(self.audio_track.add_new_bytes(chunk))
+
+                asyncio.create_task(self.audio_track.add_new_bytes(chunk))
                 await asyncio.sleep(0.001)
 
     async def aclose(self) -> None:
@@ -133,6 +155,9 @@ class OpenAITTS(TTS):
         await super().aclose()
 
     async def interrupt(self) -> None:
-        """Interrupt the TTS process"""
+        """Interrupt TTS synthesis"""
+        self._interrupted = True
+        if self._current_synthesis_task:
+            self._current_synthesis_task.cancel()
         if self.audio_track:
-            self.audio_track.interrupt()
+            self.audio_track.interrupt()

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

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

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

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