Update call_transfer.py

call_transfer.py

@@ -8,11 +8,9 @@ import asyncio
 import os
 import sys
 import time
-import json
-
-from call_connection_manager import CallConfigManager, SessionManager
 from loguru import logger
 
+from call_connection_manager import CallConfigManager, SessionManager
 from pipecat.adapters.schemas.function_schema import FunctionSchema
 from pipecat.adapters.schemas.tools_schema import ToolsSchema
 from pipecat.audio.vad.silero import SileroVADAnalyzer
@@ -42,52 +40,6 @@ logger.add(sys.stderr, level="DEBUG")
 daily_api_key = os.environ.get("HF_DAILY_API_KEY", "")
 daily_api_url = os.environ.get("DAILY_API_URL", "https://api.daily.co/v1")
 
-class SilenceDetectorProcessor(FrameProcessor):
-    """Detects prolonged silence and triggers a TTS prompt after 10 seconds."""
-    def __init__(self, session_manager, call_config_manager, tts_service, task):
-        super().__init__()
-        self.session_manager = session_manager
-        self.call_config_manager = call_config_manager
-        self.tts_service = tts_service
-        self.task = task
-        self.last_speech_time = time.time()
-        self.silence_prompt_count = 0
-        self.max_prompts = 3
-        self.silence_threshold = 10  # 10 seconds
-
-    async def process_frame(self, frame: Frame, direction: FrameDirection):
-        await super().process_frame(frame, direction)
-
-        if isinstance(frame, UserStartedSpeakingFrame):
-            self.last_speech_time = time.time()
-            self.session_manager.call_flow_state.reset_silence_prompts()
-            self.silence_prompt_count = 0
-        elif isinstance(frame, UserStoppedSpeakingFrame):
-            self.last_speech_time = time.time()
-
-        # Check for prolonged silence
-        if time.time() - self.last_speech_time >= self.silence_threshold:
-            if self.silence_prompt_count < self.max_prompts:
-                # Increment prompt count and log silence event
-                self.silence_prompt_count += 1
-                self.session_manager.call_flow_state.increment_silence_prompts()
-                logger.info(f"Silence detected for {self.silence_threshold}s, sending prompt #{self.silence_prompt_count}")
-                
-                # Send TTS prompt
-                prompt = "Hello, are you still there? How can I assist you?"
-                message = self.call_config_manager.create_system_message(prompt)
-                await self.task.queue_frames([LLMMessagesFrame([message])])
-                self.last_speech_time = time.time()  # Reset silence timer
-            else:
-                # Terminate call after max prompts
-                logger.info("Max silence prompts reached, terminating call")
-                farewell = "Thank you for calling. Goodbye."
-                message = self.call_config_manager.create_system_message(farewell)
-                await self.task.queue_frames([LLMMessagesFrame([message])])
-                await self.task.queue_frame(EndTaskFrame(), FrameDirection.UPSTREAM)
-
-        await self.push_frame(frame, direction)
-
 class TranscriptionModifierProcessor(FrameProcessor):
     """Processor that modifies transcription frames before they reach the context aggregator."""
     def __init__(self, operator_session_id_ref):
@@ -126,7 +78,6 @@ async def main(room_url: str, token: str, body: dict):
     dialed_number = caller_info["dialed_number"]
     customer_name = call_config_manager.get_customer_name(caller_number) if caller_number else None
     operator_dialout_settings = call_config_manager.get_dialout_settings_for_caller(caller_number)
-    call_start_time = time.time()  # Track call start time
 
     logger.info(f"Caller number: {caller_number}")
     logger.info(f"Dialed number: {dialed_number}")
@@ -200,18 +151,17 @@ async def main(room_url: str, token: str, body: dict):
 
     messages = [call_config_manager.create_system_message(system_instruction)]
     llm = OpenAILLMService(api_key=os.environ.get("HF_OPENAI_API_KEY"))
-    llm.register_function("terminate_call", lambda params: terminate_call(task, params, call_config_manager, call_start_time))
+    llm.register_function("terminate_call", lambda params: terminate_call(task, params))
     llm.register_function("dial_operator", dial_operator)
     context = OpenAILLMContext(messages, tools)
     context_aggregator = llm.create_context_aggregator(context)
 
     # ------------ FUNCTION DEFINITIONS ------------
-    async def terminate_call(task: PipelineTask, params: FunctionCallParams, call_config_manager, call_start_time):
+    async def terminate_call(task: PipelineTask, params: FunctionCallParams):
         content = "The user wants to end the conversation, thank them for chatting."
         message = call_config_manager.create_system_message(content)
         messages.append(message)
         await task.queue_frames([LLMMessagesFrame(messages)])
-        await call_config_manager.log_call_summary(call_start_time, session_manager, caller_number, dialed_number, customer_name)
         await params.llm.queue_frame(EndTaskFrame(), FrameDirection.UPSTREAM)
 
     async def dial_operator(params: FunctionCallParams):
@@ -257,7 +207,6 @@ async def main(room_url: str, token: str, body: dict):
     # ------------ PIPELINE SETUP ------------
     summary_finished = SummaryFinished(session_manager.call_flow_state)
     transcription_modifier = TranscriptionModifierProcessor(session_manager.get_session_id_ref("operator"))
-    silence_detector = SilenceDetectorProcessor(session_manager, call_config_manager, tts, task)
 
     async def should_speak(self) -> bool:
         return (not session_manager.call_flow_state.operator_connected or
@@ -265,7 +214,6 @@ async def main(room_url: str, token: str, body: dict):
 
     pipeline = Pipeline([
         transport.input(),
-        silence_detector,  # Add silence detection
         transcription_modifier,
         context_aggregator.user(),
         FunctionFilter(should_speak),
@@ -323,7 +271,6 @@ async def main(room_url: str, token: str, body: dict):
         logger.debug(f"Participant left: {participant}, reason: {reason}")
         if not (session_manager.get_session_id("operator") and
                 participant["id"] == session_manager.get_session_id("operator")):
-            await call_config_manager.log_call_summary(call_start_time, session_manager, caller_number, dialed_number, customer_name)
             await task.cancel()
             return
         logger.debug("Operator left the call")