voicecc 1.2.12 → 1.3.0

package/voice-server/heartbeat.py

@@ -26,6 +26,9 @@ import time
 from dataclasses import dataclass, field
 from uuid import uuid4
 
+import urllib.request
+import urllib.error
+
 from claude_agent_sdk import ClaudeAgentOptions, ClaudeSDKClient, AssistantMessage, ResultMessage, TextBlock
 
 from config import (
@@ -274,11 +277,18 @@ async def check_single_agent(agent: Agent) -> HeartbeatResult:
         )
 
         if result.should_call:
-            try:
-                await initiate_agent_call(agent, client)
-                client = None  # Don't close -- voice session owns it now
-            except Exception as e:
-                logger.error(f'[heartbeat] failed to call agent "{agent.id}": {e}')
+            outbound = agent.config.outbound_channel
+
+            if outbound == "whatsapp":
+                # Send via WhatsApp -- no session handoff needed
+                await send_whatsapp_message(agent.id, result.reason)
+            else:
+                # Default: place a Twilio call with session handoff
+                try:
+                    await initiate_agent_call(agent, client)
+                    client = None  # Don't close -- voice session owns it now
+                except Exception as e:
+                    logger.error(f'[heartbeat] failed to call agent "{agent.id}": {e}')
 
         return result
     finally:
@@ -414,14 +424,14 @@ async def initiate_agent_call(agent: Agent, client: ClaudeSDKClient) -> str:
     # Schedule cleanup for unanswered calls
     asyncio.create_task(_cleanup_pending_call(token))
 
-    # Get from number via Twilio API
+    # Get the configured Twilio phone number
     from twilio.rest import Client as TwilioClient
 
+    from_number: str = _config.twilio_phone_number
+    if not from_number:
+        raise RuntimeError("No TWILIO_PHONE_NUMBER configured")
+
     twilio_client = TwilioClient(_config.twilio_account_sid, _config.twilio_auth_token)
-    numbers = twilio_client.incoming_phone_numbers.list(limit=1)
-    if not numbers:
-        raise RuntimeError("No Twilio phone numbers found on the account")
-    from_number: str = numbers[0].phone_number or ""
 
     # Build TwiML with WebSocket stream URL
     tunnel_host = tunnel_url.replace("https://", "").replace("http://", "")
@@ -444,6 +454,63 @@ async def initiate_agent_call(agent: Agent, client: ClaudeSDKClient) -> str:
     return call.sid or ""
 
 
+async def send_whatsapp_message(agent_id: str, text: str) -> None:
+    """Send a WhatsApp message to an agent's group via the dashboard API.
+
+    POSTs { agentId, text } to the dashboard's POST /api/whatsapp/send endpoint.
+    Logs errors but does NOT raise -- the caller should not retry or fall back.
+
+    Args:
+        agent_id: Agent identifier
+        text: Message text to send
+    """
+    dashboard_port = _get_dashboard_port()
+    if not dashboard_port:
+        logger.error("[heartbeat] Cannot send WhatsApp message: dashboard port unknown")
+        return
+
+    url = f"http://localhost:{dashboard_port}/api/whatsapp/send"
+    try:
+        payload = json.dumps({"agentId": agent_id, "text": text}).encode("utf-8")
+        req = urllib.request.Request(
+            url,
+            data=payload,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        response = await asyncio.to_thread(urllib.request.urlopen, req, timeout=10)
+        if response.status == 200:
+            logger.info(f'[heartbeat] WhatsApp message sent for agent "{agent_id}"')
+        else:
+            logger.error(
+                f'[heartbeat] WhatsApp send failed for agent "{agent_id}": '
+                f"HTTP {response.status}"
+            )
+    except urllib.error.HTTPError as e:
+        logger.error(
+            f'[heartbeat] WhatsApp send failed for agent "{agent_id}": '
+            f"HTTP {e.code} -- {e.read().decode('utf-8', errors='replace')}"
+        )
+    except Exception as e:
+        logger.error(f'[heartbeat] WhatsApp send error for agent "{agent_id}": {e}')
+
+
+def _get_dashboard_port() -> int | None:
+    """Read the dashboard port from ~/.voicecc/status.json.
+
+    Returns:
+        The dashboard port number, or None if the status file is unreadable
+    """
+    voicecc_dir = os.environ.get("VOICECC_DIR", os.path.join(os.path.expanduser("~"), ".voicecc"))
+    status_path = os.path.join(voicecc_dir, "status.json")
+    try:
+        with open(status_path, "r", encoding="utf-8") as f:
+            status = json.load(f)
+        return int(status["dashboardPort"])
+    except Exception:
+        return None
+
+
 async def _cleanup_pending_call(token: str) -> None:
     """Clean up a pending call after PENDING_CALL_TIMEOUT_S if not claimed.
 

package/voice-server/server.py

@@ -86,6 +86,7 @@ async def chat_send(request: Request):
     session_key = body.get("session_key")
     text = body.get("text", "").strip()
     agent_id = body.get("agent_id")
+    resume_session_id = body.get("resume_session_id")
 
     if not session_key or not isinstance(session_key, str):
         return JSONResponse({"error": "Missing 'session_key' field"}, status_code=400)
@@ -94,35 +95,34 @@ async def chat_send(request: Request):
 
     # Get or create the chat session
     try:
-        await get_or_create_session(session_key, agent_id)
+        session = await get_or_create_session(session_key, agent_id, resume_session_id)
     except RuntimeError as e:
         logger.error(f"[server] Failed to create chat session: {e}")
         return JSONResponse({"error": str(e)}, status_code=503)
 
-    # Stream response as SSE
-    try:
-
-        async def event_generator():
-            async for event in stream_message(session_key, text):
-                data = json.dumps(event.to_dict())
-                yield f"data: {data}\n\n"
-
-        return StreamingResponse(
-            event_generator(),
-            media_type="text/event-stream",
-            headers={
-                "Cache-Control": "no-cache",
-                "Connection": "keep-alive",
-                "X-Accel-Buffering": "no",
-            },
+    # Check if already streaming before creating the StreamingResponse.
+    # This returns HTTP 409 immediately instead of an abruptly closed empty stream.
+    if session.streaming:
+        return JSONResponse(
+            {"error": "Already streaming a response. Wait for it to complete."},
+            status_code=409,
         )
-    except RuntimeError as e:
-        if "ALREADY_STREAMING" in str(e):
-            return JSONResponse(
-                {"error": "Already streaming a response. Wait for it to complete."},
-                status_code=409,
-            )
-        return JSONResponse({"error": str(e)}, status_code=500)
+
+    # Stream response as SSE
+    async def event_generator():
+        async for event in stream_message(session_key, text):
+            data = json.dumps(event.to_dict())
+            yield f"data: {data}\n\n"
+
+    return StreamingResponse(
+        event_generator(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",
+        },
+    )
 
 
 @app.post("/chat/stop")