Private-AI

Running

App Files Files Community

seawolf2357 commited on Jun 12

Commit

0d8a2ef

verified ·

1 Parent(s): e4b0406

Update app.py

Browse files

Files changed (1) hide show

app.py +268 -92

app.py CHANGED Viewed

@@ -20,6 +20,12 @@ from openai.types.beta.realtime import ResponseAudioTranscriptDoneEvent
 import httpx
 from typing import Optional, List, Dict
 import gradio as gr
 load_dotenv()
@@ -383,6 +389,9 @@ HTML_CONTENT = """<!DOCTYPE html>
         let peerConnection;
         let webrtc_id;
         let webSearchEnabled = false;
         const audioOutput = document.getElementById('audio-output');
         const startButton = document.getElementById('start-button');
         const chatMessages = document.getElementById('chat-messages');
@@ -410,6 +419,7 @@ HTML_CONTENT = """<!DOCTYPE html>
                 statusText.textContent = '연결 대기 중';
             }
         }
         function updateButtonState() {
             const button = document.getElementById('start-button');
             if (peerConnection && (peerConnection.connectionState === 'connecting' || peerConnection.connectionState === 'new')) {
@@ -439,6 +449,7 @@ HTML_CONTENT = """<!DOCTYPE html>
                 updateStatus('disconnected');
             }
         }
         function setupAudioVisualization(stream) {
             audioContext = new (window.AudioContext || window.webkitAudioContext)();
             analyser = audioContext.createAnalyser();
@@ -473,6 +484,7 @@ HTML_CONTENT = """<!DOCTYPE html>
             updateAudioLevel();
         }
         function showError(message) {
             const toast = document.getElementById('error-toast');
             toast.textContent = message;
@@ -482,9 +494,46 @@ HTML_CONTENT = """<!DOCTYPE html>
                 toast.style.display = 'none';
             }, 5000);
         }
         async function setupWebRTC() {
             const config = __RTC_CONFIGURATION__;
             peerConnection = new RTCPeerConnection(config);
             const timeoutId = setTimeout(() => {
                 const toast = document.getElementById('error-toast');
                 toast.textContent = "연결이 평소보다 오래 걸리고 있습니다. VPN을 사용 중이신가요?";
@@ -494,6 +543,7 @@ HTML_CONTENT = """<!DOCTYPE html>
                     toast.style.display = 'none';
                 }, 5000);
             }, 5000);
             try {
                 const stream = await navigator.mediaDevices.getUserMedia({
                     audio: true
@@ -502,21 +552,44 @@ HTML_CONTENT = """<!DOCTYPE html>
                 stream.getTracks().forEach(track => {
                     peerConnection.addTrack(track, stream);
                 });
                 peerConnection.addEventListener('track', (evt) => {
                     if (audioOutput.srcObject !== evt.streams[0]) {
                         audioOutput.srcObject = evt.streams[0];
                         audioOutput.play();
                     }
                 });
                 const dataChannel = peerConnection.createDataChannel('text');
                 dataChannel.onmessage = (event) => {
                     const eventJson = JSON.parse(event.data);
                     if (eventJson.type === "error") {
                         showError(eventJson.message);
                     }
                 };
                 const offer = await peerConnection.createOffer();
                 await peerConnection.setLocalDescription(offer);
                 await new Promise((resolve) => {
                     if (peerConnection.iceGatheringState === "complete") {
                         resolve();
@@ -530,15 +603,31 @@ HTML_CONTENT = """<!DOCTYPE html>
                         peerConnection.addEventListener("icegatheringstatechange", checkState);
                     }
                 });
                 peerConnection.addEventListener('connectionstatechange', () => {
                     console.log('connectionstatechange', peerConnection.connectionState);
                     if (peerConnection.connectionState === 'connected') {
                         clearTimeout(timeoutId);
                         const toast = document.getElementById('error-toast');
                         toast.style.display = 'none';
                     }
                     updateButtonState();
                 });
                 webrtc_id = Math.random().toString(36).substring(7);
                 const response = await fetch('/webrtc/offer', {
                     method: 'POST',
@@ -550,6 +639,7 @@ HTML_CONTENT = """<!DOCTYPE html>
                         web_search_enabled: webSearchEnabled
                     })
                 });
                 const serverResponse = await response.json();
                 if (serverResponse.status === 'failed') {
                     showError(serverResponse.meta.error === 'concurrency_limit_reached'
@@ -558,18 +648,27 @@ HTML_CONTENT = """<!DOCTYPE html>
                     stop();
                     return;
                 }
                 await peerConnection.setRemoteDescription(serverResponse);
                 const eventSource = new EventSource('/outputs?webrtc_id=' + webrtc_id);
                 eventSource.addEventListener("output", (event) => {
                     const eventJson = JSON.parse(event.data);
                     addMessage("assistant", eventJson.content);
                 });
                 eventSource.addEventListener("search", (event) => {
                     const eventJson = JSON.parse(event.data);
                     if (eventJson.query) {
                         addMessage("search-result", `웹 검색 중: "${eventJson.query}"`);
                     }
                 });
             } catch (err) {
                 clearTimeout(timeoutId);
                 console.error('Error setting up WebRTC:', err);
@@ -577,6 +676,7 @@ HTML_CONTENT = """<!DOCTYPE html>
                 stop();
             }
         }
         function addMessage(role, content) {
             const messageDiv = document.createElement('div');
             messageDiv.classList.add('message', role);
@@ -584,7 +684,14 @@ HTML_CONTENT = """<!DOCTYPE html>
             chatMessages.appendChild(messageDiv);
             chatMessages.scrollTop = chatMessages.scrollHeight;
         }
         function stop() {
             if (animationFrame) {
                 cancelAnimationFrame(animationFrame);
             }
@@ -613,6 +720,7 @@ HTML_CONTENT = """<!DOCTYPE html>
             updateButtonState();
             audioLevel = 0;
         }
         startButton.addEventListener('click', () => {
             console.log('clicked');
             console.log(peerConnection, peerConnection?.connectionState);
@@ -666,14 +774,14 @@ class BraveSearchClient:
                         })
                 return results
             except Exception as e:
-                print(f"Brave Search error: {e}")
                 return []
 # Initialize search client globally
 brave_api_key = os.getenv("BSEARCH_API")
 search_client = BraveSearchClient(brave_api_key) if brave_api_key else None
-print(f"Search client initialized: {search_client is not None}, API key present: {bool(brave_api_key)}")
 # Store web search settings by connection
 web_search_settings = {}
@@ -699,7 +807,10 @@ class OpenAIHandler(AsyncStreamHandler):
         self.current_call_id = None
         self.webrtc_id = webrtc_id
         self.web_search_enabled = web_search_enabled
-        print(f"Handler created with web_search_enabled={web_search_enabled}, webrtc_id={webrtc_id}")
     def copy(self):
         # Get the most recent settings
@@ -712,10 +823,10 @@ class OpenAIHandler(AsyncStreamHandler):
                 recent_id = recent_ids[0]
                 settings = web_search_settings[recent_id]
                 web_search_enabled = settings.get('enabled', False)
-                print(f"Handler.copy() using recent settings - webrtc_id={recent_id}, web_search_enabled={web_search_enabled}")
                 return OpenAIHandler(web_search_enabled=web_search_enabled, webrtc_id=recent_id)
-        print(f"Handler.copy() called - creating new handler with default settings")
         return OpenAIHandler(web_search_enabled=False)
     async def search_web(self, query: str) -> str:
@@ -723,7 +834,7 @@ class OpenAIHandler(AsyncStreamHandler):
         if not self.search_client or not self.web_search_enabled:
             return "웹 검색이 비활성화되어 있습니다."
-        print(f"Searching web for: {query}")
         results = await self.search_client.search(query)
         if not results:
             return f"'{query}'에 대한 검색 결과를 찾을 수 없습니다."
@@ -739,6 +850,31 @@ class OpenAIHandler(AsyncStreamHandler):
         return f"웹 검색 결과 '{query}':\n\n" + "\n".join(formatted_results)
     async def start_up(self):
         """Connect to realtime API with function calling enabled"""
         # First check if we have the most recent settings
@@ -751,10 +887,11 @@ class OpenAIHandler(AsyncStreamHandler):
                 settings = web_search_settings[recent_id]
                 self.web_search_enabled = settings.get('enabled', False)
                 self.webrtc_id = recent_id
-                print(f"start_up: Updated settings from storage - webrtc_id={self.webrtc_id}, web_search_enabled={self.web_search_enabled}")
-        print(f"Starting up handler with web_search_enabled={self.web_search_enabled}")
         self.client = openai.AsyncOpenAI()
         # Define the web search function
         tools = []
@@ -778,7 +915,7 @@ class OpenAIHandler(AsyncStreamHandler):
                     }
                 }
             }]
-            print("Web search function added to tools")
             instructions = (
                 "You are a helpful assistant with web search capabilities. "
@@ -794,101 +931,136 @@ class OpenAIHandler(AsyncStreamHandler):
                 "than to guess or use outdated information. Always respond in Korean when the user speaks Korean."
             )
-        async with self.client.beta.realtime.connect(
-            model="gpt-4o-mini-realtime-preview-2024-12-17"
-        ) as conn:
-            # Update session with tools
-            session_update = {
-                "turn_detection": {"type": "server_vad"},
-                "instructions": instructions,
-                "tools": tools,
-                "tool_choice": "auto" if tools else "none"
-            }
-            await conn.session.update(session=session_update)
-            self.connection = conn
-            print(f"Connected with tools: {len(tools)} functions")
-            async for event in self.connection:
-                # Debug logging for function calls
-                if event.type.startswith("response.function_call"):
-                    print(f"Function event: {event.type}")
-                if event.type == "response.audio_transcript.done":
-                    await self.output_queue.put(AdditionalOutputs(event))
-                elif event.type == "response.audio.delta":
-                    await self.output_queue.put(
-                        (
-                            self.output_sample_rate,
-                            np.frombuffer(
-                                base64.b64decode(event.delta), dtype=np.int16
-                            ).reshape(1, -1),
-                        ),
-                    )
-                # Handle function calls
-                elif event.type == "response.function_call_arguments.start":
-                    print(f"Function call started")
-                    self.function_call_in_progress = True
-                    self.current_function_args = ""
-                    self.current_call_id = getattr(event, 'call_id', None)
-                elif event.type == "response.function_call_arguments.delta":
-                    if self.function_call_in_progress:
-                        self.current_function_args += event.delta
-                elif event.type == "response.function_call_arguments.done":
-                    if self.function_call_in_progress:
-                        print(f"Function call done, args: {self.current_function_args}")
-                        try:
-                            args = json.loads(self.current_function_args)
-                            query = args.get("query", "")
-                            # Emit search event to client
-                            await self.output_queue.put(AdditionalOutputs({
-                                "type": "search",
-                                "query": query
-                            }))
-                            # Perform the search
-                            search_results = await self.search_web(query)
-                            print(f"Search results length: {len(search_results)}")
-                            # Send function result back to the model
-                            if self.connection and self.current_call_id:
-                                await self.connection.conversation.item.create(
-                                    item={
-                                        "type": "function_call_output",
-                                        "call_id": self.current_call_id,
-                                        "output": search_results
-                                    }
-                                )
-                                await self.connection.response.create()
-                        except Exception as e:
-                            print(f"Function call error: {e}")
-                        finally:
-                            self.function_call_in_progress = False
-                            self.current_function_args = ""
-                            self.current_call_id = None
     async def receive(self, frame: tuple[int, np.ndarray]) -> None:
-        if not self.connection:
             return
         try:
             _, array = frame
             array = array.squeeze()
             audio_message = base64.b64encode(array.tobytes()).decode("utf-8")
             await self.connection.input_audio_buffer.append(audio=audio_message)
         except Exception as e:
-            print(f"Error in receive: {e}")
-            # Connection might be closed, ignore the error
     async def emit(self) -> tuple[int, np.ndarray] | AdditionalOutputs | None:
         return await wait_for_item(self.output_queue)
     async def shutdown(self) -> None:
         if self.connection:
             await self.connection.close()
             self.connection = None
@@ -900,7 +1072,7 @@ handler = OpenAIHandler(web_search_enabled=False)
 # Create components
 chatbot = gr.Chatbot(type="messages")
-# Create stream with handler instance
 stream = Stream(
     handler,  # Pass instance, not factory
     mode="send-receive",
@@ -910,7 +1082,7 @@ stream = Stream(
     additional_outputs_handler=update_chatbot,
     rtc_configuration=get_twilio_turn_credentials() if get_space() else None,
     concurrency_limit=5 if get_space() else None,
-    time_limit=90 if get_space() else None,
 )
 app = FastAPI()
@@ -927,7 +1099,7 @@ async def custom_offer(request: Request):
     webrtc_id = body.get("webrtc_id")
     web_search_enabled = body.get("web_search_enabled", False)
-    print(f"Custom offer - webrtc_id: {webrtc_id}, web_search_enabled: {web_search_enabled}")
     # Store settings with timestamp
     if webrtc_id:
@@ -959,9 +1131,13 @@ async def outputs(webrtc_id: str):
     async def output_stream():
         async for output in stream.output_stream(webrtc_id):
             if hasattr(output, 'args') and output.args:
-                # Check if it's a search event
-                if isinstance(output.args[0], dict) and output.args[0].get('type') == 'search':
-                    yield f"event: search\ndata: {json.dumps(output.args[0])}\n\n"
                 # Regular transcript event
                 elif hasattr(output.args[0], 'transcript'):
                     s = json.dumps({"role": "assistant", "content": output.args[0].transcript})

 import httpx
 from typing import Optional, List, Dict
 import gradio as gr
+import logging
+from datetime import datetime
+# 로깅 설정
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 load_dotenv()
         let peerConnection;
         let webrtc_id;
         let webSearchEnabled = false;
+        let reconnectAttempts = 0;
+        let heartbeatInterval;
+        let connectionHealthInterval;
         const audioOutput = document.getElementById('audio-output');
         const startButton = document.getElementById('start-button');
         const chatMessages = document.getElementById('chat-messages');
                 statusText.textContent = '연결 대기 중';
             }
         }
         function updateButtonState() {
             const button = document.getElementById('start-button');
             if (peerConnection && (peerConnection.connectionState === 'connecting' || peerConnection.connectionState === 'new')) {
                 updateStatus('disconnected');
             }
         }
         function setupAudioVisualization(stream) {
             audioContext = new (window.AudioContext || window.webkitAudioContext)();
             analyser = audioContext.createAnalyser();
             updateAudioLevel();
         }
         function showError(message) {
             const toast = document.getElementById('error-toast');
             toast.textContent = message;
                 toast.style.display = 'none';
             }, 5000);
         }
+        // 연결 상태 모니터링 함수
+        function startConnectionHealthCheck() {
+            if (connectionHealthInterval) {
+                clearInterval(connectionHealthInterval);
+            }
+            connectionHealthInterval = setInterval(() => {
+                if (peerConnection) {
+                    const state = peerConnection.connectionState;
+                    const iceState = peerConnection.iceConnectionState;
+                    console.log(`Connection state: ${state}, ICE state: ${iceState}`);
+                    if (state === 'failed' || state === 'closed' || iceState === 'failed') {
+                        console.log('Connection lost, attempting to reconnect...');
+                        handleConnectionLoss();
+                    }
+                }
+            }, 3000); // 3초마다 체크
+        }
+        // 연결 손실 처리
+        function handleConnectionLoss() {
+            if (reconnectAttempts < 3) {
+                reconnectAttempts++;
+                showError(`연결이 끊어졌습니다. 재연결 시도 중... (${reconnectAttempts}/3)`);
+                stop();
+                setTimeout(() => {
+                    setupWebRTC();
+                }, 2000);
+            } else {
+                showError('연결을 복구할 수 없습니다. 새로고침 후 다시 시도해주세요.');
+                stop();
+            }
+        }
         async function setupWebRTC() {
             const config = __RTC_CONFIGURATION__;
             peerConnection = new RTCPeerConnection(config);
             const timeoutId = setTimeout(() => {
                 const toast = document.getElementById('error-toast');
                 toast.textContent = "연결이 평소보다 오래 걸리고 있습니다. VPN을 사용 중이신가요?";
                     toast.style.display = 'none';
                 }, 5000);
             }, 5000);
             try {
                 const stream = await navigator.mediaDevices.getUserMedia({
                     audio: true
                 stream.getTracks().forEach(track => {
                     peerConnection.addTrack(track, stream);
                 });
                 peerConnection.addEventListener('track', (evt) => {
                     if (audioOutput.srcObject !== evt.streams[0]) {
                         audioOutput.srcObject = evt.streams[0];
                         audioOutput.play();
                     }
                 });
                 const dataChannel = peerConnection.createDataChannel('text');
+                // Heartbeat 메시지 전송
+                dataChannel.onopen = () => {
+                    console.log('Data channel opened');
+                    if (heartbeatInterval) clearInterval(heartbeatInterval);
+                    heartbeatInterval = setInterval(() => {
+                        if (dataChannel.readyState === 'open') {
+                            dataChannel.send(JSON.stringify({ type: 'heartbeat' }));
+                        }
+                    }, 30000); // 30초마다 heartbeat
+                };
                 dataChannel.onmessage = (event) => {
                     const eventJson = JSON.parse(event.data);
                     if (eventJson.type === "error") {
                         showError(eventJson.message);
+                    } else if (eventJson.type === "connection_lost") {
+                        handleConnectionLoss();
                     }
                 };
+                dataChannel.onclose = () => {
+                    console.log('Data channel closed');
+                    if (heartbeatInterval) clearInterval(heartbeatInterval);
+                };
                 const offer = await peerConnection.createOffer();
                 await peerConnection.setLocalDescription(offer);
                 await new Promise((resolve) => {
                     if (peerConnection.iceGatheringState === "complete") {
                         resolve();
                         peerConnection.addEventListener("icegatheringstatechange", checkState);
                     }
                 });
+                // 모든 연결 상태 이벤트 모니터링
                 peerConnection.addEventListener('connectionstatechange', () => {
                     console.log('connectionstatechange', peerConnection.connectionState);
                     if (peerConnection.connectionState === 'connected') {
                         clearTimeout(timeoutId);
                         const toast = document.getElementById('error-toast');
                         toast.style.display = 'none';
+                        reconnectAttempts = 0;
+                        startConnectionHealthCheck();
+                    } else if (peerConnection.connectionState === 'failed') {
+                        handleConnectionLoss();
                     }
                     updateButtonState();
                 });
+                peerConnection.addEventListener('iceconnectionstatechange', () => {
+                    console.log('ICE connection state:', peerConnection.iceConnectionState);
+                    if (peerConnection.iceConnectionState === 'disconnected') {
+                        showError('네트워크 연결이 불안정합니다');
+                    } else if (peerConnection.iceConnectionState === 'failed') {
+                        handleConnectionLoss();
+                    }
+                });
                 webrtc_id = Math.random().toString(36).substring(7);
                 const response = await fetch('/webrtc/offer', {
                     method: 'POST',
                         web_search_enabled: webSearchEnabled
                     })
                 });
                 const serverResponse = await response.json();
                 if (serverResponse.status === 'failed') {
                     showError(serverResponse.meta.error === 'concurrency_limit_reached'
                     stop();
                     return;
                 }
                 await peerConnection.setRemoteDescription(serverResponse);
                 const eventSource = new EventSource('/outputs?webrtc_id=' + webrtc_id);
                 eventSource.addEventListener("output", (event) => {
                     const eventJson = JSON.parse(event.data);
                     addMessage("assistant", eventJson.content);
                 });
                 eventSource.addEventListener("search", (event) => {
                     const eventJson = JSON.parse(event.data);
                     if (eventJson.query) {
                         addMessage("search-result", `웹 검색 중: "${eventJson.query}"`);
                     }
                 });
+                eventSource.addEventListener("error", (event) => {
+                    console.error('EventSource error:', event);
+                    handleConnectionLoss();
+                });
             } catch (err) {
                 clearTimeout(timeoutId);
                 console.error('Error setting up WebRTC:', err);
                 stop();
             }
         }
         function addMessage(role, content) {
             const messageDiv = document.createElement('div');
             messageDiv.classList.add('message', role);
             chatMessages.appendChild(messageDiv);
             chatMessages.scrollTop = chatMessages.scrollHeight;
         }
         function stop() {
+            if (heartbeatInterval) {
+                clearInterval(heartbeatInterval);
+            }
+            if (connectionHealthInterval) {
+                clearInterval(connectionHealthInterval);
+            }
             if (animationFrame) {
                 cancelAnimationFrame(animationFrame);
             }
             updateButtonState();
             audioLevel = 0;
         }
         startButton.addEventListener('click', () => {
             console.log('clicked');
             console.log(peerConnection, peerConnection?.connectionState);
                         })
                 return results
             except Exception as e:
+                logger.error(f"Brave Search error: {e}")
                 return []
 # Initialize search client globally
 brave_api_key = os.getenv("BSEARCH_API")
 search_client = BraveSearchClient(brave_api_key) if brave_api_key else None
+logger.info(f"Search client initialized: {search_client is not None}, API key present: {bool(brave_api_key)}")
 # Store web search settings by connection
 web_search_settings = {}
         self.current_call_id = None
         self.webrtc_id = webrtc_id
         self.web_search_enabled = web_search_enabled
+        self.keep_alive_task = None
+        self.last_activity = datetime.now()
+        self.connection_active = True
+        logger.info(f"Handler created with web_search_enabled={web_search_enabled}, webrtc_id={webrtc_id}")
     def copy(self):
         # Get the most recent settings
                 recent_id = recent_ids[0]
                 settings = web_search_settings[recent_id]
                 web_search_enabled = settings.get('enabled', False)
+                logger.info(f"Handler.copy() using recent settings - webrtc_id={recent_id}, web_search_enabled={web_search_enabled}")
                 return OpenAIHandler(web_search_enabled=web_search_enabled, webrtc_id=recent_id)
+        logger.info(f"Handler.copy() called - creating new handler with default settings")
         return OpenAIHandler(web_search_enabled=False)
     async def search_web(self, query: str) -> str:
         if not self.search_client or not self.web_search_enabled:
             return "웹 검색이 비활성화되어 있습니다."
+        logger.info(f"Searching web for: {query}")
         results = await self.search_client.search(query)
         if not results:
             return f"'{query}'에 대한 검색 결과를 찾을 수 없습니다."
         return f"웹 검색 결과 '{query}':\n\n" + "\n".join(formatted_results)
+    async def keep_alive(self):
+        """Keep the connection alive with periodic activity checks"""
+        while self.connection_active:
+            try:
+                await asyncio.sleep(30)  # 30초마다 체크
+                # 마지막 활동으로부터 5분이 지났는지 확인
+                inactive_time = (datetime.now() - self.last_activity).total_seconds()
+                if inactive_time > 300:  # 5분
+                    logger.warning(f"Connection inactive for {inactive_time} seconds")
+                # 연결 상태 확인
+                if self.connection:
+                    logger.debug("Connection alive - sending keepalive")
+                    # OpenAI 연결은 자동으로 유지됨
+                else:
+                    logger.error("Connection lost in keep_alive")
+                    self.connection_active = False
+                    break
+            except Exception as e:
+                logger.error(f"Keep-alive error: {e}")
+                self.connection_active = False
+                break
     async def start_up(self):
         """Connect to realtime API with function calling enabled"""
         # First check if we have the most recent settings
                 settings = web_search_settings[recent_id]
                 self.web_search_enabled = settings.get('enabled', False)
                 self.webrtc_id = recent_id
+                logger.info(f"start_up: Updated settings from storage - webrtc_id={self.webrtc_id}, web_search_enabled={self.web_search_enabled}")
+        logger.info(f"Starting up handler with web_search_enabled={self.web_search_enabled}")
         self.client = openai.AsyncOpenAI()
+        self.connection_active = True
         # Define the web search function
         tools = []
                     }
                 }
             }]
+            logger.info("Web search function added to tools")
             instructions = (
                 "You are a helpful assistant with web search capabilities. "
                 "than to guess or use outdated information. Always respond in Korean when the user speaks Korean."
             )
+        try:
+            async with self.client.beta.realtime.connect(
+                model="gpt-4o-mini-realtime-preview-2024-12-17"
+            ) as conn:
+                # Update session with tools
+                session_update = {
+                    "turn_detection": {"type": "server_vad"},
+                    "instructions": instructions,
+                    "tools": tools,
+                    "tool_choice": "auto" if tools else "none"
+                }
+                await conn.session.update(session=session_update)
+                self.connection = conn
+                self.last_activity = datetime.now()
+                logger.info(f"Connected with tools: {len(tools)} functions")
+                # Start keep-alive task
+                self.keep_alive_task = asyncio.create_task(self.keep_alive())
+                async for event in self.connection:
+                    self.last_activity = datetime.now()
+                    # Debug logging for function calls
+                    if event.type.startswith("response.function_call"):
+                        logger.debug(f"Function event: {event.type}")
+                    if event.type == "response.audio_transcript.done":
+                        await self.output_queue.put(AdditionalOutputs(event))
+                    elif event.type == "response.audio.delta":
+                        await self.output_queue.put(
+                            (
+                                self.output_sample_rate,
+                                np.frombuffer(
+                                    base64.b64decode(event.delta), dtype=np.int16
+                                ).reshape(1, -1),
+                            ),
+                        )
+                    # Handle function calls
+                    elif event.type == "response.function_call_arguments.start":
+                        logger.info(f"Function call started")
+                        self.function_call_in_progress = True
+                        self.current_function_args = ""
+                        self.current_call_id = getattr(event, 'call_id', None)
+                    elif event.type == "response.function_call_arguments.delta":
+                        if self.function_call_in_progress:
+                            self.current_function_args += event.delta
+                    elif event.type == "response.function_call_arguments.done":
+                        if self.function_call_in_progress:
+                            logger.info(f"Function call done, args: {self.current_function_args}")
+                            try:
+                                args = json.loads(self.current_function_args)
+                                query = args.get("query", "")
+                                # Emit search event to client
+                                await self.output_queue.put(AdditionalOutputs({
+                                    "type": "search",
+                                    "query": query
+                                }))
+                                # Perform the search
+                                search_results = await self.search_web(query)
+                                logger.info(f"Search results length: {len(search_results)}")
+                                # Send function result back to the model
+                                if self.connection and self.current_call_id:
+                                    await self.connection.conversation.item.create(
+                                        item={
+                                            "type": "function_call_output",
+                                            "call_id": self.current_call_id,
+                                            "output": search_results
+                                        }
+                                    )
+                                    await self.connection.response.create()
+                            except Exception as e:
+                                logger.error(f"Function call error: {e}")
+                            finally:
+                                self.function_call_in_progress = False
+                                self.current_function_args = ""
+                                self.current_call_id = None
+        except Exception as e:
+            logger.error(f"Connection error in start_up: {e}")
+            self.connection_active = False
+            # 연결 오류를 클라이언트에 알림
+            await self.output_queue.put(AdditionalOutputs({
+                "type": "connection_lost",
+                "message": "서버 연결이 끊어졌습니다"
+            }))
     async def receive(self, frame: tuple[int, np.ndarray]) -> None:
+        if not self.connection or not self.connection_active:
             return
         try:
+            self.last_activity = datetime.now()
             _, array = frame
             array = array.squeeze()
             audio_message = base64.b64encode(array.tobytes()).decode("utf-8")
             await self.connection.input_audio_buffer.append(audio=audio_message)
         except Exception as e:
+            logger.error(f"Error in receive: {e}")
+            # 연결이 끊어진 경우 상태 업데이트
+            if "closed" in str(e).lower() or "connection" in str(e).lower():
+                self.connection = None
+                self.connection_active = False
+                # 클라이언트에 연결 종료 알림
+                await self.output_queue.put(AdditionalOutputs({
+                    "type": "connection_lost",
+                    "message": "연결이 종료되었습니다"
+                }))
     async def emit(self) -> tuple[int, np.ndarray] | AdditionalOutputs | None:
         return await wait_for_item(self.output_queue)
     async def shutdown(self) -> None:
+        logger.info("Shutting down handler")
+        self.connection_active = False
+        if self.keep_alive_task:
+            self.keep_alive_task.cancel()
+            try:
+                await self.keep_alive_task
+            except asyncio.CancelledError:
+                pass
         if self.connection:
             await self.connection.close()
             self.connection = None
 # Create components
 chatbot = gr.Chatbot(type="messages")
+# Create stream with handler instance - 시간 제한 제거
 stream = Stream(
     handler,  # Pass instance, not factory
     mode="send-receive",
     additional_outputs_handler=update_chatbot,
     rtc_configuration=get_twilio_turn_credentials() if get_space() else None,
     concurrency_limit=5 if get_space() else None,
+    time_limit=None,  # 시간 제한 제거
 )
 app = FastAPI()
     webrtc_id = body.get("webrtc_id")
     web_search_enabled = body.get("web_search_enabled", False)
+    logger.info(f"Custom offer - webrtc_id: {webrtc_id}, web_search_enabled: {web_search_enabled}")
     # Store settings with timestamp
     if webrtc_id:
     async def output_stream():
         async for output in stream.output_stream(webrtc_id):
             if hasattr(output, 'args') and output.args:
+                # Check if it's a search event or connection lost event
+                if isinstance(output.args[0], dict):
+                    event_type = output.args[0].get('type')
+                    if event_type == 'search':
+                        yield f"event: search\ndata: {json.dumps(output.args[0])}\n\n"
+                    elif event_type == 'connection_lost':
+                        yield f"event: error\ndata: {json.dumps(output.args[0])}\n\n"
                 # Regular transcript event
                 elif hasattr(output.args[0], 'transcript'):
                     s = json.dumps({"role": "assistant", "content": output.args[0].transcript})