Method _handle_unity_message

relay/server.py:298–340

Handle a message from Unity

(
        self,
        instance: UnityInstance,
        msg: dict[str, Any],
    )

            await self.registry.disconnect_with_grace_period(instance_id, self.reload_grace_period_ms)

    async def _handle_unity_message(
        self,
        instance: UnityInstance,
        msg: dict[str, Any],
    ) -> None:
        """Handle a message from Unity"""
        msg_type = msg.get("type")
        instance.update_heartbeat()

        if msg_type == MessageType.STATUS.value:
            status_str = msg.get("status", "")
            detail = _sanitize_detail(msg.get("detail"))
            try:
                status = InstanceStatus(status_str)
                old_status = instance.status
                self.registry.update_status(instance.instance_id, status, detail)
                # Process queued commands when Unity transitions from BUSY to READY
                if old_status == InstanceStatus.BUSY and status == InstanceStatus.READY:
                    await self._process_queue(instance)
            except ValueError:
                logger.warning("Unknown status: %s", status_str)

        elif msg_type == MessageType.COMMAND_RESULT.value:
            request_id = msg.get("id", "")
            logger.info(f"COMMAND_RESULT received: id={request_id}")
            logger.info(f"Pending commands: {list(self._pending_commands.keys())}")
            if request_id in self._pending_commands:
                future = self._pending_commands.pop(request_id)
                if not future.done():
                    logger.info(f"Resolving command result for {request_id}")
                    future.set_result(msg)
            else:
                # Late result (already timed out)
                logger.warning(f"Ignoring late COMMAND_RESULT for {request_id} (not in pending)")

        elif msg_type == MessageType.PONG.value:
            # Heartbeat response - signal the waiting heartbeat loop
            if instance.instance_id in self._pending_pongs:
                self._pending_pongs[instance.instance_id].set()
                logger.debug(f"PONG received from {instance.instance_id}")

        else:
            logger.warning(f"Unknown Unity message type: {msg_type}")

    async def _heartbeat_loop(self, instance_id: str) -> None:
        """