infinicode 2.8.66 → 2.8.68

package/packages/robopark/scheduler/main.py

@@ -14,7 +14,7 @@ import hashlib
 import hmac
 import time
 from datetime import datetime, timedelta
-from typing import Optional, List
+from typing import Optional, List
 from contextlib import asynccontextmanager
 
 from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException, Query, Header
@@ -230,6 +230,20 @@ class PipelineEventPayload(BaseModel):
     session_id: Optional[str] = None
     source: str = "robot"
     details: Optional[dict] = None
+
+class TranscriptTurnPayload(BaseModel):
+    role: str
+    text: str
+    speaker: Optional[str] = None
+    is_final: bool = True
+    sequence: Optional[int] = None
+    source: str = "voice_agent"
+    metadata: Optional[dict] = None
+
+class VoiceCallRequest(BaseModel):
+    character_preset_id: str
+    voice_stack_id: Optional[str] = None
+    client_name: str = "RoboPark Operator"
 
 class SupervisorStatusReport(BaseModel):
     services: List[ServiceStatus] = []
@@ -471,6 +485,23 @@ async def init_db():
             );
             CREATE INDEX IF NOT EXISTS idx_pipeline_robot_time
                 ON pipeline_events(robot_id, timestamp DESC);
+
+            CREATE TABLE IF NOT EXISTS session_transcripts (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                session_id TEXT NOT NULL,
+                robot_id TEXT,
+                role TEXT NOT NULL,
+                speaker TEXT,
+                text TEXT NOT NULL,
+                is_final INTEGER NOT NULL DEFAULT 1,
+                sequence INTEGER,
+                source TEXT NOT NULL DEFAULT 'voice_agent',
+                metadata TEXT,
+                timestamp TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+            );
+            CREATE INDEX IF NOT EXISTS idx_transcript_session_time
+                ON session_transcripts(session_id, timestamp, id);
 
             -- Scheduler-managed voice stacks (STT/LLM/TTS configuration)
             CREATE TABLE IF NOT EXISTS voice_stacks (
@@ -558,7 +589,11 @@ async def init_db():
             # started_at at INSERT time; existing rows on an upgraded DB will
             # have NULL here until touched, so readers should fall back to
             # started_at (see the /status endpoint below).
-            ("sessions", "last_activity_at", "TEXT"),
+            ("sessions", "last_activity_at", "TEXT"),
+            ("sessions", "character_id", "TEXT"),
+            ("sessions", "voice_stack_id", "TEXT"),
+            ("sessions", "initiated_by", "TEXT"),
+            ("sessions", "event_token_hash", "TEXT"),
         ):
             try:
                 await db.execute(f"ALTER TABLE {_table} ADD COLUMN {_column} {_coldef}")
@@ -1238,14 +1273,104 @@ class WebClientSessionRequest(BaseModel):
     """Request body for web client session"""
     client_name: Optional[str] = "Web User"
 
-class WebClientSessionResponse(BaseModel):
+class WebClientSessionResponse(BaseModel):
     """Response for web client session"""
     session_id: str
     server_id: str
     server_url: str
     room_name: str
     api_key: str
-    api_secret: str
+    api_secret: str
+
+async def _select_available_server(db):
+    async with db.execute("""
+        SELECT s.*,
+               (SELECT COUNT(*) FROM sessions WHERE server_id = s.id AND ended_at IS NULL) AS active
+        FROM livekit_servers s
+        WHERE s.status = 'online'
+        ORDER BY active ASC
+        LIMIT 1
+    """) as cursor:
+        server = await cursor.fetchone()
+    if not server:
+        raise HTTPException(503, "No available servers")
+    if server["active"] >= server["max_sessions"]:
+        raise HTTPException(503, "All servers at capacity")
+    return server
+
+@app.post("/api/sessions/voice-call")
+async def create_voice_call(payload: VoiceCallRequest):
+    """Create a browser voice call using a frozen character and voice stack.
+
+    Unlike the legacy web-client endpoint this never exposes LiveKit API
+    credentials. The event token only authorizes transcript writes for this
+    session and is stored as a hash.
+    """
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        async with db.execute(
+            "SELECT * FROM character_presets WHERE id = ?", (payload.character_preset_id,)
+        ) as cursor:
+            character = await cursor.fetchone()
+        if not character:
+            raise HTTPException(404, "Character preset not found")
+        stack_id = payload.voice_stack_id or character["voice_stack_id"]
+        if not stack_id:
+            raise HTTPException(422, "Character has no voice stack")
+        async with db.execute("SELECT id FROM voice_stacks WHERE id = ?", (stack_id,)) as cursor:
+            if not await cursor.fetchone():
+                raise HTTPException(404, "Voice stack not found")
+        server = await _select_available_server(db)
+        now = datetime.utcnow()
+        nonce = secrets.token_urlsafe(8).replace("-", "").replace("_", "")
+        session_id = f"voice_{now.strftime('%Y%m%d%H%M%S')}_{nonce}"
+        room_name = f"robopark-voice-{nonce}"
+        event_token = secrets.token_urlsafe(32)
+        await db.execute("""
+            INSERT INTO sessions
+                (id, robot_id, server_id, room_name, started_at, last_activity_at,
+                 character_id, voice_stack_id, initiated_by, event_token_hash)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """, (
+            session_id, "operator-call", server["id"], room_name,
+            now.isoformat(), now.isoformat(), character["id"], stack_id,
+            (payload.client_name or "RoboPark Operator")[:80], _hash(event_token),
+        ))
+        await db.commit()
+
+    try:
+        from livekit.api import AccessToken, VideoGrants
+    except ImportError:
+        raise HTTPException(503, "livekit-api not installed on scheduler")
+    identity = f"operator:{nonce}"
+    token = (
+        AccessToken(server["api_key"] or "devkey", server["api_secret"] or "secret")
+        .with_identity(identity)
+        .with_name((payload.client_name or "RoboPark Operator")[:80])
+        .with_ttl(timedelta(hours=2))
+        .with_grants(VideoGrants(
+            room=room_name, room_join=True, can_publish=True,
+            can_subscribe=True, can_publish_data=True,
+        ))
+        .to_jwt()
+    )
+    await _log_history(
+        "session", "session", session_id, "voice_call_started",
+        (payload.client_name or "operator")[:64],
+        f"character={character['id']}, voice_stack={stack_id}",
+    )
+    await broadcast("voice_call_started", {"session_id": session_id, "character_id": character["id"]})
+    return {
+        "session_id": session_id,
+        "server_id": server["id"],
+        "server_url": server["url"],
+        "room_name": room_name,
+        "identity": identity,
+        "token": token,
+        "event_token": event_token,
+        "character": {"id": character["id"], "name": character["name"], "img": character["img"]},
+        "voice_stack_id": stack_id,
+    }
 
 @app.post("/api/sessions/web-client", response_model=WebClientSessionResponse)
 async def create_web_client_session(req: Optional[WebClientSessionRequest] = None):
@@ -1333,17 +1458,18 @@ def _session_latency_ms(started_at: Optional[str], joined_at: Optional[str]) ->
     except Exception:
         return None
 
-@app.post("/api/sessions/{session_id}/joined")
-async def session_joined(session_id: str,
-                         authorization: Optional[str] = Header(default=None)):
+@app.post("/api/sessions/{session_id}/joined")
+async def session_joined(session_id: str,
+                         authorization: Optional[str] = Header(default=None),
+                         session_token: Optional[str] = Header(default=None, alias="X-RoboPark-Session-Token")):
     """Mark the moment a robot successfully joined the LiveKit room for a session.
 
     Used to compute session latency = joined_at - started_at (the session row's
     started_at is set when the session is requested). Requires a valid
     enrolled-device Bearer token. Idempotent: the first join wins; later calls
     leave the original join time in place."""
-    if not await _authorize_fleet(authorization):
-        raise HTTPException(401, "Invalid or missing device token")
+    if not await _session_event_authorized(session_id, session_token, authorization, None):
+        raise HTTPException(401, "Invalid or missing device token")
     now = datetime.utcnow().isoformat()
     async with aiosqlite.connect(DB_PATH) as db:
         db.row_factory = aiosqlite.Row
@@ -1497,17 +1623,160 @@ async def get_session_token(session_id: str):
 
     return {"token": token, "room_name": room_name}
 
-@app.get("/api/sessions")
-async def list_sessions(active_only: bool = False, limit: int = 50):
-    """List sessions"""
-    async with aiosqlite.connect(DB_PATH) as db:
-        db.row_factory = aiosqlite.Row
-        if active_only:
-            query = "SELECT * FROM sessions WHERE ended_at IS NULL ORDER BY started_at DESC"
-        else:
-            query = f"SELECT * FROM sessions ORDER BY started_at DESC LIMIT {limit}"
-        async with db.execute(query) as cursor:
-            return [dict(row) for row in await cursor.fetchall()]
+@app.get("/api/sessions")
+async def list_sessions(active_only: bool = False, limit: int = 50):
+    """List enriched sessions for the operator history and live views."""
+    limit = max(1, min(limit, 1000))
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        base = """SELECT s.*, s.id AS session_id,
+                    cp.name AS character_name, cp.img AS character_img,
+                    CASE WHEN s.joined_at IS NOT NULL THEN
+                      CAST((julianday(s.joined_at) - julianday(s.started_at)) * 86400000 AS INTEGER)
+                    END AS avg_latency_ms,
+                    (SELECT COUNT(*) FROM session_transcripts t
+                     WHERE t.session_id = s.id AND t.is_final = 1) AS transcript_count,
+                    (SELECT COUNT(*) FROM pipeline_events p
+                     WHERE p.session_id = s.id AND p.status IN ('failed','blocked')) AS error_count,
+                    (SELECT COUNT(*) FROM pipeline_events p
+                     WHERE p.session_id = s.id) AS pipeline_event_count
+                  FROM sessions s
+                  LEFT JOIN character_presets cp ON cp.id = COALESCE(
+                    s.character_id,
+                    (SELECT character_id FROM devices d WHERE d.id = s.robot_id),
+                    (SELECT character_id FROM robots r WHERE r.id = s.robot_id)
+                  )"""
+        if active_only:
+            query = base + " WHERE s.ended_at IS NULL ORDER BY s.started_at DESC"
+        else:
+            query = base + " ORDER BY s.started_at DESC LIMIT ?"
+        async with db.execute(query, () if active_only else (limit,)) as cursor:
+            return [dict(row) for row in await cursor.fetchall()]
+
+async def _session_event_authorized(session_id: str, session_token: Optional[str],
+                                    authorization: Optional[str], agent_token: Optional[str]) -> bool:
+    if await _authorize_fleet(authorization):
+        return True
+    if ROBOPARK_AGENT_TOKEN and agent_token and hmac.compare_digest(agent_token.strip(), ROBOPARK_AGENT_TOKEN):
+        return True
+    if not session_token:
+        return False
+    async with aiosqlite.connect(DB_PATH) as db:
+        async with db.execute("SELECT event_token_hash FROM sessions WHERE id = ?", (session_id,)) as cursor:
+            row = await cursor.fetchone()
+    return bool(row and row[0] and hmac.compare_digest(row[0], _hash(session_token.strip())))
+
+@app.post("/api/sessions/{session_id}/transcript")
+async def append_session_transcript(
+    session_id: str,
+    payload: TranscriptTurnPayload,
+    authorization: Optional[str] = Header(default=None),
+    agent_token: Optional[str] = Header(default=None, alias="X-RoboPark-Agent-Token"),
+    session_token: Optional[str] = Header(default=None, alias="X-RoboPark-Session-Token"),
+):
+    if not await _session_event_authorized(session_id, session_token, authorization, agent_token):
+        raise HTTPException(401, "Invalid or missing session event token")
+    role = (payload.role or "").strip().lower()
+    if role not in {"user", "assistant", "system", "tool"}:
+        raise HTTPException(422, "role must be user, assistant, system, or tool")
+    text = (payload.text or "").strip()
+    if not text:
+        raise HTTPException(422, "text is required")
+    if len(text) > 20000:
+        raise HTTPException(422, "text exceeds 20000 characters")
+    now = datetime.utcnow().isoformat()
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        async with db.execute("SELECT robot_id, ended_at FROM sessions WHERE id = ?", (session_id,)) as cursor:
+            session = await cursor.fetchone()
+        if not session:
+            raise HTTPException(404, "Session not found")
+        cur = await db.execute("""
+            INSERT INTO session_transcripts
+                (session_id, robot_id, role, speaker, text, is_final, sequence, source, metadata, timestamp)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """, (
+            session_id, session["robot_id"], role, (payload.speaker or "")[:120] or None,
+            text, int(payload.is_final), payload.sequence, (payload.source or "unknown")[:40],
+            json.dumps(payload.metadata or {}, separators=(",", ":"))[:8000], now,
+        ))
+        if not session["ended_at"]:
+            await db.execute("UPDATE sessions SET last_activity_at = ? WHERE id = ?", (now, session_id))
+        await db.commit()
+    await broadcast("transcript_turn", {"session_id": session_id, "role": role, "is_final": payload.is_final})
+    return {"status": "ok", "id": cur.lastrowid, "timestamp": now}
+
+@app.post("/api/sessions/by-room/{room_name}/transcript")
+async def append_room_transcript(
+    room_name: str,
+    payload: TranscriptTurnPayload,
+    authorization: Optional[str] = Header(default=None),
+    agent_token: Optional[str] = Header(default=None, alias="X-RoboPark-Agent-Token"),
+):
+    """Persist a ROBOVOICE turn without coupling the worker to session ID formats."""
+    async with aiosqlite.connect(DB_PATH) as db:
+        async with db.execute(
+            "SELECT id FROM sessions WHERE room_name = ? ORDER BY started_at DESC LIMIT 1",
+            (room_name,),
+        ) as cursor:
+            row = await cursor.fetchone()
+    if not row:
+        raise HTTPException(404, "No session bound to this room")
+    return await append_session_transcript(
+        row[0], payload, authorization=authorization, agent_token=agent_token, session_token=None
+    )
+
+@app.get("/api/sessions/{session_id}/detail")
+async def session_detail(session_id: str):
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        async with db.execute("""
+            SELECT s.*, s.id AS session_id, cp.name AS character_name, cp.img AS character_img,
+                   vs.name AS voice_stack_name
+            FROM sessions s
+            LEFT JOIN character_presets cp ON cp.id = COALESCE(
+                s.character_id,
+                (SELECT character_id FROM devices d WHERE d.id = s.robot_id),
+                (SELECT character_id FROM robots r WHERE r.id = s.robot_id)
+            )
+            LEFT JOIN voice_stacks vs ON vs.id = COALESCE(s.voice_stack_id, cp.voice_stack_id)
+            WHERE s.id = ?
+        """, (session_id,)) as cursor:
+            session = await cursor.fetchone()
+        if not session:
+            raise HTTPException(404, "Session not found")
+        async with db.execute(
+            "SELECT * FROM session_transcripts WHERE session_id = ? ORDER BY COALESCE(sequence, id), timestamp, id",
+            (session_id,),
+        ) as cursor:
+            transcript = [dict(r) for r in await cursor.fetchall()]
+        async with db.execute(
+            "SELECT * FROM pipeline_events WHERE session_id = ? ORDER BY timestamp, id", (session_id,)
+        ) as cursor:
+            pipeline = [dict(r) for r in await cursor.fetchall()]
+    for turn in transcript:
+        try:
+            turn["metadata"] = json.loads(turn.get("metadata") or "{}")
+        except Exception:
+            turn["metadata"] = {}
+        turn["is_final"] = bool(turn.get("is_final"))
+    for event in pipeline:
+        try:
+            event["details"] = json.loads(event.get("details") or "{}")
+        except Exception:
+            event["details"] = {}
+    data = dict(session)
+    data.pop("event_token_hash", None)
+    data["latency_ms"] = _session_latency_ms(data.get("started_at"), data.get("joined_at"))
+    data["transcript"] = transcript
+    data["pipeline_events"] = pipeline
+    data["summary"] = {
+        "turns": len([t for t in transcript if t["is_final"]]),
+        "user_turns": len([t for t in transcript if t["is_final"] and t["role"] == "user"]),
+        "assistant_turns": len([t for t in transcript if t["is_final"] and t["role"] == "assistant"]),
+        "pipeline_errors": len([e for e in pipeline if e["status"] in {"failed", "blocked"}]),
+    }
+    return data
 
 @app.get("/api/sessions/stats")
 async def session_stats():
@@ -2168,7 +2437,17 @@ async def preview_agent(robot_id: str, authorization: Optional[str] = Header(def
     """The ROBOT polls this. While an operator preview is active it returns a
     PUBLISH token + room so the Pi opens its cam and joins; otherwise
     {active:false} so the Pi stops publishing. Enrolled-device auth."""
-    if not await _authorize_fleet(authorization):
+    fleet_authorized = await _authorize_fleet(authorization)
+    event_authorized = False
+    if session_token:
+        async with aiosqlite.connect(DB_PATH) as auth_db:
+            async with auth_db.execute("SELECT event_token_hash FROM sessions WHERE id = ?", (session_id,)) as c:
+                auth_row = await c.fetchone()
+        event_authorized = bool(
+            auth_row and auth_row[0]
+            and hmac.compare_digest(auth_row[0], _hash(session_token.strip()))
+        )
+    if not fleet_authorized and not event_authorized:
         raise HTTPException(401, "Invalid or missing device token")
     async with aiosqlite.connect(DB_PATH) as db:
         db.row_factory = aiosqlite.Row
@@ -3640,7 +3919,7 @@ async def _auto_elevenlabs_voice(robot_name: Optional[str], current: Optional[st
     return current
 
 
-async def _resolve_robot_voice_config(robot_id: str) -> RobotVoiceConfig:
+async def _resolve_robot_voice_config(robot_id: str) -> RobotVoiceConfig:
     """Public helper to resolve the effective voice config for a robot id."""
     async with aiosqlite.connect(DB_PATH) as db:
         db.row_factory = aiosqlite.Row
@@ -3692,14 +3971,48 @@ async def _resolve_robot_voice_config(robot_id: str) -> RobotVoiceConfig:
         if stack_dict:
             stack_dict["tts_voice"] = await _auto_elevenlabs_voice(character_name or character_id, stack_dict.get("tts_voice"))
         voice_stack = VoiceStack(**stack_dict) if stack_dict else None
-        return RobotVoiceConfig(
+        return RobotVoiceConfig(
             character_id=character_id,
             character_name=character_name,
             system_prompt=system_prompt,
             voice_stack_id=voice_stack.id if voice_stack else None,
             voice_stack=voice_stack,
-            greeting_phrases=greeting_phrases,
-        )
+            greeting_phrases=greeting_phrases,
+        )
+
+async def _resolve_session_voice_config(session_row) -> RobotVoiceConfig:
+    """Resolve the immutable character/stack snapshot selected for a web call."""
+    character_id = session_row["character_id"]
+    stack_id = session_row["voice_stack_id"]
+    if not character_id:
+        return await _resolve_robot_voice_config(session_row["robot_id"])
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        async with db.execute(
+            "SELECT name, system_prompt, voice_stack_id FROM character_presets WHERE id = ?",
+            (character_id,),
+        ) as cursor:
+            character = await cursor.fetchone()
+        stack_id = stack_id or (character["voice_stack_id"] if character else None)
+        stack = None
+        if stack_id:
+            async with db.execute("SELECT * FROM voice_stacks WHERE id = ?", (stack_id,)) as cursor:
+                stack_row = await cursor.fetchone()
+            if stack_row:
+                stack_data = dict(stack_row)
+                stack_data["tts_voice"] = await _auto_elevenlabs_voice(
+                    character["name"] if character else character_id,
+                    stack_data.get("tts_voice"),
+                )
+                stack = VoiceStack(**stack_data)
+    return RobotVoiceConfig(
+        character_id=character_id,
+        character_name=character["name"] if character else character_id,
+        system_prompt=character["system_prompt"] if character else None,
+        voice_stack_id=stack.id if stack else stack_id,
+        voice_stack=stack,
+        greeting_phrases=[],
+    )
 
 
 @app.get("/api/voice-stacks", response_model=List[VoiceStack])
@@ -4186,22 +4499,24 @@ async def update_robot_voice_config(robot_id: str, payload: RobotVoiceConfigUpda
 
 
 @app.get("/api/devices/by-room/{room_name}/voice-config", response_model=RobotVoiceConfig)
-async def get_device_voice_config_by_room(room_name: str):
+async def get_device_voice_config_by_room(room_name: str):
     """ROBOVOICE agent calls this when it joins a room to fetch per-robot config."""
     async with aiosqlite.connect(DB_PATH) as db:
         db.row_factory = aiosqlite.Row
-        async with db.execute(
-            "SELECT robot_id FROM sessions WHERE room_name = ? ORDER BY started_at DESC LIMIT 1",
-            (room_name,),
-        ) as c:
-            session = await c.fetchone()
+        async with db.execute(
+            "SELECT robot_id, character_id, voice_stack_id FROM sessions WHERE room_name = ? ORDER BY started_at DESC LIMIT 1",
+            (room_name,),
+        ) as c:
+            session = await c.fetchone()
         if not session:
             if room_name.startswith("robopark-"):
                 device_id = room_name[len("robopark-"):]
                 if device_id:
                     return await _resolve_robot_voice_config(device_id)
-            raise HTTPException(404, "No session bound to this room")
-        return await _resolve_robot_voice_config(session["robot_id"])
+            raise HTTPException(404, "No session bound to this room")
+        if session["character_id"]:
+            return await _resolve_session_voice_config(session)
+        return await _resolve_robot_voice_config(session["robot_id"])
 
 
 # =============================================================================
@@ -4213,18 +4528,45 @@ async def _robot_telemetry(db, robot_id: str) -> Optional[dict]:
 
     Returns trigger_count, sessions_total, avg_latency_ms, drop_rate, drops and
     an end_reason breakdown; None if the robot does not exist."""
-    async with db.execute(
-        "SELECT trigger_count, name, status, current_session_id, connected_server_id FROM robots WHERE id = ?", (robot_id,)
-    ) as c:
+    async with db.execute(
+        "SELECT trigger_count, name, status, current_session_id, connected_server_id, character_id FROM robots WHERE id = ?", (robot_id,)
+    ) as c:
         robot = await c.fetchone()
     if not robot:
         return None
     trigger_count = robot["trigger_count"] or 0
 
-    async with db.execute(
-        "SELECT status, production_mode, last_heartbeat FROM devices WHERE id = ?", (robot_id,)
-    ) as c:
-        device = await c.fetchone()
+    async with db.execute(
+        """SELECT status, production_mode, last_heartbeat, character_id,
+                  video_device, audio_device, audio_output_device,
+                  device_inventory, supervisor_status, supervisor_status_at
+           FROM devices WHERE id = ?""",
+        (robot_id,),
+    ) as c:
+        device = await c.fetchone()
+
+    character_id = (device["character_id"] if device else None) or robot["character_id"]
+    character_name = None
+    character_img = None
+    if character_id:
+        async with db.execute(
+            "SELECT name, img FROM character_presets WHERE id = ?", (character_id,)
+        ) as c:
+            character = await c.fetchone()
+        if character:
+            character_name = character["name"]
+            character_img = character["img"]
+
+    def parse_json_field(value, fallback):
+        if not value:
+            return fallback
+        try:
+            return json.loads(value)
+        except (TypeError, ValueError, json.JSONDecodeError):
+            return fallback
+
+    device_inventory = parse_json_field(device["device_inventory"], {}) if device else {}
+    supervisor_status = parse_json_field(device["supervisor_status"], []) if device else []
     session = None
     if robot["current_session_id"]:
         async with db.execute(
@@ -4319,7 +4661,10 @@ async def _robot_telemetry(db, robot_id: str) -> Optional[dict]:
 
     return {
         "robot_id": robot_id,
-        "name": robot["name"],
+        "name": robot["name"],
+        "character_id": character_id,
+        "character_name": character_name,
+        "character_img": character_img,
         "lan_ip": lan_ip,
         "vision_port": DEFAULT_VISION_PORT,
         "trigger_count": trigger_count,
@@ -4335,7 +4680,13 @@ async def _robot_telemetry(db, robot_id: str) -> Optional[dict]:
         "session_age_seconds": session_age,
         "session_activity_age_seconds": activity_age,
         "heartbeat_age_seconds": heartbeat_age,
-        "device_status": device["status"] if device else None,
+        "device_status": device["status"] if device else None,
+        "video_device": device["video_device"] if device else None,
+        "audio_device": device["audio_device"] if device else None,
+        "audio_output_device": device["audio_output_device"] if device else None,
+        "device_inventory": device_inventory,
+        "supervisor_status": supervisor_status,
+        "supervisor_status_at": device["supervisor_status_at"] if device else None,
         "production_mode": bool(device["production_mode"]) if device else False,
         "readiness_code": readiness_code,
         "readiness_message": readiness_message,