Realtime Flow

src/agent_session/main.py

@@ -1,10 +1,11 @@
 #!/usr/bin/env python3
 """
-Agent Session for Avurna Flow, wrapped in a FastAPI server.
+Agent Session for Avurna Flow, wrapped in a FastAPI server. (DEBUGGING ENABLED)
 """
 import asyncio
 import os
 import json
+import traceback # Import traceback to print full errors
 from fastapi import FastAPI, BackgroundTasks
 from pydantic import BaseModel
 import uvicorn
@@ -21,8 +22,8 @@ from livekit.plugins.silero import VAD
 from src.agent_session.constants import SYSTEM_PROMPT, GREETING_INSTRUCTIONS
 from src.utils import validate_env_vars
 
+# --- FastAPI and CORS setup (unchanged) ---
 app = FastAPI()
-
 origins = ["*"]
 app.add_middleware(
     CORSMiddleware,
@@ -44,12 +45,11 @@ async def send_agent_state(ctx: JobContext, state: str):
     try:
         msg = json.dumps({"type": "agent_state", "state": state})
         await ctx.room.local_participant.publish_data(msg)
-        print(f"Sent agent state: {state}")
+        print(f"DEBUG: Sent agent state: {state}")
     except Exception as e:
-        print(f"Error publishing agent state: {e}")
+        print(f"DEBUG: Error publishing agent state: {e}")
 
-# --- KEY FIX: Create a proper wrapper CLASS for the LLM ---
-# This class conforms to the interface that AgentSession expects.
+# --- KEY FIX 2: Correctly yield from the wrapped LLM chat method ---
 class LLMStateWrapper(LLM):
     def __init__(self, llm: LLM, ctx: JobContext):
         super().__init__()
@@ -58,50 +58,63 @@ class LLMStateWrapper(LLM):
 
     async def chat(self, history):
         await send_agent_state(self._ctx, "thinking")
-        res_stream = self._llm.chat(history)
-        await send_agent_state(self._ctx, "speaking")
-        return res_stream
+        # The `yield from` is crucial for streaming responses.
+        async for chunk in self._llm.chat(history):
+            yield chunk
+        await send_agent_state(self._ctx, "listening") # Change state back to listening after speaking is done
+
 
-# --- Main agent session logic ---
 async def run_agent_session(room_name: str, agent_token: str):
+    # --- KEY FIX 1: Add aggressive "breadcrumb" logging ---
+    print(f"DEBUG: Starting run_agent_session for room: {room_name}")
     livekit_url = os.getenv("LIVEKIT_URL")
     ctx = JobContext(room_name=room_name, livekit_url=livekit_url, token=agent_token)
     
     try:
+        print("DEBUG: 1. Connecting to LiveKit context...")
         await ctx.connect()
+        print("DEBUG: 2. Context connected. Sending initial 'listening' state.")
         await send_agent_state(ctx, "listening")
 
-        # --- KEY FIX: Instantiate the wrapper class correctly ---
+        print("DEBUG: 3. Initializing plugins (VAD, STT, LLM, TTS)...")
         llm_state_wrapper = LLMStateWrapper(
             llm=GoogleLLM(model="gemini-1.5-flash", temperature=0.5),
             ctx=ctx
         )
-
         vad = VAD.load(min_speech_duration=0.1, min_silence_duration=0.5)
+        stt = StreamAdapter(stt=STT(model="whisper-large-v3-turbo", language="en"), vad=vad)
+        tts = TTS(voice=VoiceByName(name="Tiktok Fashion Influencer", provider=VoiceProvider.hume), instant_mode=True)
+        print("DEBUG: 4. Plugins initialized.")
+
+        print("DEBUG: 5. Creating AgentSession...")
         session = AgentSession(
             vad=vad,
-            stt=StreamAdapter(stt=STT(model="whisper-large-v3-turbo", language="en"), vad=vad),
-            llm=llm_state_wrapper, # Use the class instance here
-            tts=TTS(voice=VoiceByName(name="Tiktok Fashion Influencer", provider=VoiceProvider.hume), instant_mode=True),
+            stt=stt,
+            llm=llm_state_wrapper,
+            tts=tts,
         )
-
-        print(f"Agent starting session in room: {room_name}")
+        print("DEBUG: 6. AgentSession created. Starting session now...")
         await session.start(agent=VoiceAssistant(), room=ctx.room)
         
+        print("DEBUG: 7. Session started. Generating initial greeting...")
         await send_agent_state(ctx, "speaking")
         await session.generate_reply(instructions=GREETING_INSTRUCTIONS)
-        await send_agent_state(ctx, "listening")
+        # Note: The state is now set back to 'listening' inside the LLM wrapper
+        
+        print("DEBUG: 8. Initial greeting complete. Agent is now fully operational.")
     
     except Exception as e:
-        print(f"An error occurred during the agent session: {e}")
+        # This will now print the FULL error to your Hugging Face logs
+        print(f"FATAL ERROR in agent session: {e}")
+        print(traceback.format_exc())
     finally:
-        print(f"Agent session ended for room: {room_name}. Cleaning up.")
+        print(f"DEBUG: Agent session for room {room_name} is ending. Cleaning up.")
         await ctx.disconnect()
 
 
 @app.post("/join-room")
 async def join_room(req: JoinRoomRequest, background_tasks: BackgroundTasks):
-    print(f"Received request for agent to join room: {req.room_name}")
+    print(f"DEBUG: Received request for agent to join room: {req.room_name}")
     background_tasks.add_task(run_agent_session, req.room_name, req.agent_token)
     return {"status": "agent_joining"}