feat: updating mac os images

TEJASNARAYANS · TEJASNARAYANS · commit 0a8167fe59ac · 2026-03-17T18:53:32.000Z
diff --git a/.gitignore b/.gitignore
@@ -29,7 +29,6 @@ env/
 ENV/
 .venv
 config.yml
-config.docker.yml
 # uv
 .python-version
 uv.lock
diff --git a/app/api/v1/routes/data_sources.py b/app/api/v1/routes/data_sources.py
@@ -42,7 +42,7 @@ async def test_s3_connection(api_key: str = Depends(get_api_key)):
     if not enabled:
         error = s3_service.get_status_message() or "S3 is not enabled or not configured."
         raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail=f"S3 connection test failed: {error}",
         )
     
diff --git a/app/api/v1/routes/voice_agent.py b/app/api/v1/routes/voice_agent.py
@@ -450,8 +450,11 @@ def resolve_api_key_for_provider(provider: ModelProvider) -> str | None:
             # Continue to try creating evaluator result if we have metadata
         
         # Create evaluator result if we have the required data (only if no error)
-        # Create evaluator result for all test calls (with or without persona/scenario)
-        if call_metadata and call_metadata.get("s3_key") and not call_metadata.get("error") and agent_id and result_id:
+        # Also create if we have a live transcript even without S3 audio
+        has_audio = call_metadata and call_metadata.get("s3_key")
+        has_transcript = call_metadata and call_metadata.get("transcription")
+        has_usable_data = has_audio or has_transcript
+        if call_metadata and has_usable_data and not call_metadata.get("error") and agent_id and result_id:
             # If we don't have evaluator but have persona/scenario, try to create one
             if not evaluator and agent_id and persona_id and scenario_id:
                 try:
@@ -523,7 +526,9 @@ def resolve_api_key_for_provider(provider: ModelProvider) -> str | None:
                         name=result_name,
                         duration_seconds=call_metadata.get("duration"),
                         status=EvaluatorResultStatus.QUEUED.value,  # Use .value to get the string
-                        audio_s3_key=call_metadata.get("s3_key")
+                        audio_s3_key=call_metadata.get("s3_key"),
+                        transcription=call_metadata.get("transcription"),
+                        speaker_segments=call_metadata.get("speaker_segments"),
                     )
                     db.add(evaluator_result)
                     db.commit()
diff --git a/app/services/voice_agent/bot_fast_api.py b/app/services/voice_agent/bot_fast_api.py
@@ -237,6 +237,8 @@ async def run_bot(websocket_client, google_api_key: str, system_instruction: str
     call_start_time = time.time()
     s3_key_result = None
     duration_result = None
+    transcript_text = None
+    conversation_turns = []
     
     try:
         ws_transport = imports["FastAPIWebsocketTransport"](
@@ -360,6 +362,34 @@ async def on_client_disconnected(transport, client):
                 evaluator_id=evaluator_id,
                 result_id=result_id,
             )
+            
+            # Extract conversation transcript from the LLM context
+            try:
+                raw_messages = context.messages if hasattr(context, 'messages') else []
+                conversation_turns = []
+                transcript_parts = []
+                elapsed = 0.0
+                for msg in raw_messages:
+                    role = msg.get("role", "")
+                    content = msg.get("content", "")
+                    if not content or role == "system":
+                        continue
+                    speaker = "user" if role == "user" else "assistant"
+                    turn_duration = max(1.0, len(content.split()) * 0.4)
+                    conversation_turns.append({
+                        "speaker": speaker,
+                        "text": content,
+                        "start": round(elapsed, 2),
+                        "end": round(elapsed + turn_duration, 2),
+                    })
+                    transcript_parts.append(f"{speaker}: {content}")
+                    elapsed += turn_duration
+                transcript_text = "\n".join(transcript_parts) if transcript_parts else None
+                logger.info(f"Captured {len(conversation_turns)} conversation turns from live Gemini pipeline")
+            except Exception as ctx_err:
+                logger.warning(f"Failed to extract conversation context: {ctx_err}")
+                conversation_turns = []
+                transcript_text = None
 
     except Exception as e:
         logger.error(f"Error in run_bot: {e}", exc_info=True)
@@ -369,24 +399,21 @@ async def on_client_disconnected(transport, client):
             "agent_id": agent_id,
             "persona_id": persona_id,
             "scenario_id": scenario_id,
+            "transcription": transcript_text,
+            "speaker_segments": conversation_turns if conversation_turns else None,
             "error": str(e)
         }
     
-    if s3_key_result:
-        return {
-            "s3_key": s3_key_result,
-            "duration": duration_result,
-            "agent_id": agent_id,
-            "persona_id": persona_id,
-            "scenario_id": scenario_id
-        }
-    else:
-        return {
-            "s3_key": None,
-            "duration": duration_result,
-            "agent_id": agent_id,
-            "persona_id": persona_id,
-            "scenario_id": scenario_id,
-            "error": "No audio file was uploaded"
-        }
+    metadata = {
+        "s3_key": s3_key_result,
+        "duration": duration_result,
+        "agent_id": agent_id,
+        "persona_id": persona_id,
+        "scenario_id": scenario_id,
+        "transcription": transcript_text,
+        "speaker_segments": conversation_turns if conversation_turns else None,
+    }
+    if not s3_key_result and not transcript_text:
+        metadata["error"] = "No audio file was uploaded and no transcript captured"
+    return metadata
 
diff --git a/app/services/voice_agent/voice_bundle.py b/app/services/voice_agent/voice_bundle.py
@@ -448,6 +448,8 @@ async def run_voice_bundle_fastapi(
     call_start_time = time.time()
     s3_key_result = None
     duration_result = None
+    transcript_text = None
+    conversation_turns = []
     
     # Storage for audio data from the buffer processor
     recorded_audio_data = {"audio": None, "sample_rate": None, "num_channels": None}
@@ -643,6 +645,34 @@ async def on_client_disconnected(transport, client):
             # Calculate duration
             duration_result = time.time() - call_start_time
             
+            # Extract conversation transcript from the LLM context
+            try:
+                raw_messages = context.messages if hasattr(context, 'messages') else []
+                conversation_turns = []
+                transcript_parts = []
+                elapsed = 0.0
+                for msg in raw_messages:
+                    role = msg.get("role", "")
+                    content = msg.get("content", "")
+                    if not content or role == "system":
+                        continue
+                    speaker = "user" if role == "user" else "assistant"
+                    turn_duration = max(1.0, len(content.split()) * 0.4)
+                    conversation_turns.append({
+                        "speaker": speaker,
+                        "text": content,
+                        "start": round(elapsed, 2),
+                        "end": round(elapsed + turn_duration, 2),
+                    })
+                    transcript_parts.append(f"{speaker}: {content}")
+                    elapsed += turn_duration
+                transcript_text = "\n".join(transcript_parts) if transcript_parts else None
+                logger.info(f"Captured {len(conversation_turns)} conversation turns from live pipeline")
+            except Exception as ctx_err:
+                logger.warning(f"Failed to extract conversation context: {ctx_err}")
+                conversation_turns = []
+                transcript_text = None
+            
             # Merge captured audio chunks
             total_input_audio = b''.join(input_audio_chunks) if input_audio_chunks else b''
             total_output_audio = b''.join(output_audio_chunks) if output_audio_chunks else b''
@@ -700,26 +730,23 @@ async def on_client_disconnected(transport, client):
             "agent_id": agent_id,
             "persona_id": persona_id,
             "scenario_id": scenario_id,
+            "transcription": transcript_text,
+            "speaker_segments": conversation_turns if conversation_turns else None,
             "error": str(e),
         }
 
-    if s3_key_result:
-        return {
-            "s3_key": s3_key_result,
-            "duration": duration_result,
-            "agent_id": agent_id,
-            "persona_id": persona_id,
-            "scenario_id": scenario_id,
-        }
-
-    return {
-        "s3_key": None,
+    metadata = {
+        "s3_key": s3_key_result,
         "duration": duration_result,
         "agent_id": agent_id,
         "persona_id": persona_id,
         "scenario_id": scenario_id,
-        "error": "No audio file was uploaded",
+        "transcription": transcript_text,
+        "speaker_segments": conversation_turns if conversation_turns else None,
     }
+    if not s3_key_result and not transcript_text:
+        metadata["error"] = "No audio file was uploaded and no transcript captured"
+    return metadata
 
 
 if __name__ == "__main__":
diff --git a/app/workers/tasks/process_evaluator_result.py b/app/workers/tasks/process_evaluator_result.py
@@ -87,6 +87,90 @@ def _transcribe_audio(result, ai_providers, db):
     )
 
 
+def _generate_call_analysis(transcription, ai_providers, organization_id, result_id, db, agent=None, scenario=None):
+    """Generate call analysis (summary, sentiment, success) using LLM."""
+    from app.services.ai.llm_service import llm_service
+
+    llm_provider = ModelProvider.OPENAI
+    llm_model = "gpt-4o-mini"
+
+    chosen_provider = next(
+        (p for p in ai_providers if provider_matches(p.provider, llm_provider)),
+        None,
+    )
+    if not chosen_provider:
+        llm_provider = ModelProvider.GOOGLE
+        llm_model = "gemini-2.0-flash"
+        chosen_provider = next(
+            (p for p in ai_providers if provider_matches(p.provider, llm_provider)),
+            None,
+        )
+    if not chosen_provider:
+        logger.warning(f"[EvaluatorResult {result_id}] No LLM provider available for call analysis")
+        return None
+
+    agent_context = ""
+    if agent and agent.description:
+        agent_context = f"\n\nAgent Description:\n{agent.description}"
+    if scenario:
+        scenario_name = getattr(scenario, 'name', '')
+        scenario_desc = getattr(scenario, 'description', '')
+        if scenario_name or scenario_desc:
+            agent_context += f"\n\nScenario: {scenario_name}"
+            if scenario_desc:
+                agent_context += f"\nScenario Description: {scenario_desc}"
+
+    messages = [
+        {
+            "role": "system",
+            "content": (
+                "You are a call analysis expert. Analyze the following conversation transcript "
+                "and provide a structured analysis. Respond ONLY with valid JSON, no markdown."
+            ),
+        },
+        {
+            "role": "user",
+            "content": f"""Analyze this conversation transcript and provide:
+1. A concise summary of the call (2-3 sentences)
+2. The user/caller's overall sentiment (one of: Positive, Negative, Neutral, Mixed)
+3. Whether the call was successful in achieving its objective (true/false)
+{agent_context}
+
+Transcript:
+{transcription}
+
+Respond in this exact JSON format:
+{{"call_summary": "...", "user_sentiment": "...", "call_successful": true/false}}""",
+        },
+    ]
+
+    try:
+        llm_result = llm_service.generate_response(
+            messages=messages,
+            llm_provider=llm_provider,
+            llm_model=llm_model,
+            organization_id=organization_id,
+            db=db,
+            temperature=0.3,
+            max_tokens=500,
+        )
+        import json
+        import re
+        text = llm_result.get("text", "")
+        json_match = re.search(r'\{[^{}]*\}', text, re.DOTALL)
+        if json_match:
+            analysis = json.loads(json_match.group())
+            required_keys = {"call_summary", "user_sentiment", "call_successful"}
+            if required_keys.issubset(analysis.keys()):
+                logger.info(f"[EvaluatorResult {result_id}] Call analysis generated successfully")
+                return analysis
+        logger.warning(f"[EvaluatorResult {result_id}] Could not parse call analysis from LLM response")
+        return None
+    except Exception as e:
+        logger.error(f"[EvaluatorResult {result_id}] Call analysis failed: {e}", exc_info=True)
+        return None
+
+
 def _categorize_metrics(enabled_metrics, has_audio):
     """Split metrics into LLM-evaluable and audio-only categories."""
     llm_metrics = []
@@ -247,7 +331,26 @@ def process_evaluator_result_task(self, result_id: str):
                         "skipping evaluation"
                     )
 
-            # Step 5: Complete
+            # Step 5: Call Analysis
+            if transcription and not (result.call_data and result.call_data.get("call_analysis")):
+                try:
+                    call_analysis = _generate_call_analysis(
+                        transcription=transcription,
+                        ai_providers=ai_providers,
+                        organization_id=result.organization_id,
+                        result_id=result.result_id,
+                        db=db,
+                        agent=agent,
+                        scenario=scenario,
+                    )
+                    if call_analysis:
+                        result.call_data = {"call_analysis": call_analysis}
+                except Exception as analysis_err:
+                    logger.warning(
+                        f"[EvaluatorResult {result.result_id}] Call analysis failed (non-fatal): {analysis_err}"
+                    )
+
+            # Step 6: Complete
             result.metric_scores = metric_scores
             result.status = EvaluatorResultStatus.COMPLETED.value
             db.commit()
diff --git a/docker-compose.yml b/docker-compose.yml
@@ -81,11 +81,16 @@ services:
     # Use host network mode for WebRTC connectivity (Retell/Vapi calls)
     network_mode: host
     environment:
+      # Worker is on host network, so it reaches DB/Redis via localhost (exposed ports)
+      DATABASE_URL: postgresql://${POSTGRES_USER:-efficientai}:${POSTGRES_PASSWORD:-password}@localhost:5432/${POSTGRES_DB:-efficientai}
+      REDIS_URL: redis://localhost:6379/0
+      CELERY_BROKER_URL: redis://localhost:6379/0
+      CELERY_RESULT_BACKEND: redis://localhost:6379/0
       ENCRYPTION_KEY: ${ENCRYPTION_KEY:-}
     volumes:
       - ./uploads:/app/uploads
       - ./.encryption_key:/app/.encryption_key:ro
-      - ./config.yml:/app/config.yml:ro
+      - ./config.docker.yml:/app/config.yml:ro
     command: eai worker --config /app/config.yml --loglevel info
 
 volumes:
diff --git a/frontend/src/components/VoiceAgent.tsx b/frontend/src/components/VoiceAgent.tsx
@@ -9,9 +9,11 @@ import { useState, useRef, useEffect } from 'react'
 import { PipecatClient, PipecatClientOptions, RTVIEvent } from '@pipecat-ai/client-js'
 import { WebSocketTransport } from '@pipecat-ai/websocket-transport'
 import ReactMarkdown from 'react-markdown'
-import { Mic, MicOff, Loader, MessageSquare } from 'lucide-react'
+import { Mic, MicOff, Loader, MessageSquare, AlertTriangle } from 'lucide-react'
+import { useQuery } from '@tanstack/react-query'
 import Button from './Button'
 import { useAgentStore } from '../store/agentStore'
+import { apiClient } from '../lib/api'
 
 interface VoiceAgentProps {
   personaId?: string
@@ -30,6 +32,12 @@ export default function VoiceAgent({ personaId, scenarioId, agentId }: VoiceAgen
   const [error, setError] = useState<string | null>(null)
   const [logs, setLogs] = useState<Array<{ timestamp: string; message: string; type: 'user' | 'bot' | 'system' }>>([])
 
+  const { data: s3Status } = useQuery({
+    queryKey: ['s3-status'],
+    queryFn: () => apiClient.getS3Status(),
+    staleTime: 60_000,
+  })
+
   const pcClientRef = useRef<PipecatClient | null>(null)
   const botAudioRef = useRef<HTMLAudioElement | null>(null)
   const isConnectingRef = useRef(false) // Guard to prevent multiple simultaneous connections
@@ -311,6 +319,18 @@ export default function VoiceAgent({ personaId, scenarioId, agentId }: VoiceAgen
           </div>
         </div>
 
+        {s3Status && !s3Status.enabled && (
+          <div className="flex items-start gap-3 bg-amber-50 border border-amber-200 rounded-lg p-4 mb-4">
+            <AlertTriangle className="h-5 w-5 text-amber-500 flex-shrink-0 mt-0.5" />
+            <div>
+              <p className="text-sm font-medium text-amber-800">Storage not configured</p>
+              <p className="text-xs text-amber-700 mt-0.5">
+                Audio recordings will not be saved. Transcripts and analysis will still be captured from the live conversation.
+              </p>
+            </div>
+          </div>
+        )}
+
         {error && (
           <div className="bg-red-50 border border-red-200 rounded-lg p-4 mb-4">
             <p className="text-sm text-red-800">{error}</p>
diff --git a/frontend/src/components/call-recordings/TestVoiceAgentResultDetails.tsx b/frontend/src/components/call-recordings/TestVoiceAgentResultDetails.tsx
diff --git a/frontend/src/pages/playground/agent/AgentPlayground.tsx b/frontend/src/pages/playground/agent/AgentPlayground.tsx
diff --git a/frontend/src/pages/playground/agent/TestAgentResultDetail.tsx b/frontend/src/pages/playground/agent/TestAgentResultDetail.tsx

Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ async def test_s3_connection(api_key: str = Depends(get_api_key)):`
`42`	`42`	`if not enabled:`
`43`	`43`	`error = s3_service.get_status_message() or "S3 is not enabled or not configured."`
`44`	`44`	`raise HTTPException(`
`45`		`- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,`
	`45`	`+ status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,`
`46`	`46`	`detail=f"S3 connection test failed: {error}",`
`47`	`47`	`)`
`48`	`48`