src/Pure/Tools/server_commands.scala

 {
   def default_preferences: String = Options.read_prefs()
 
   object Cancel
   {
-    sealed case class Args(task: UUID)
+    sealed case class Args(task: UUID.T)
 
     def unapply(json: JSON.T): Option[Args] =
       for { task <- JSON.uuid(json, "task") }
       yield Args(task)
   }

         print_mode <- JSON.strings_default(json, "print_mode")
       }
       yield Args(build = build, print_mode = print_mode)
 
     def command(args: Args, progress: Progress = No_Progress, log: Logger = No_Logger)
-      : (JSON.Object.T, (UUID, Headless.Session)) =
+      : (JSON.Object.T, (UUID.T, Headless.Session)) =
     {
       val base_info =
         try { Session_Build.command(args.build, progress = progress)._3 }
         catch { case exn: Server.Error => error(exn.message) }
 

           session_base = Some(base_info.check_base),
           print_mode = args.print_mode,
           progress = progress,
           log = log)
 
-      val id = UUID()
+      val id = UUID.random()
 
       val res =
         JSON.Object(
           "session_id" -> id.toString,
           "tmp_dir" -> File.path(session.tmp_dir).implode)

     }
   }
 
   object Session_Stop
   {
-    def unapply(json: JSON.T): Option[UUID] =
+    def unapply(json: JSON.T): Option[UUID.T] =
       JSON.uuid(json, "session_id")
 
     def command(session: Headless.Session): (JSON.Object.T, Process_Result) =
     {
       val result = session.stop()

   }
 
   object Use_Theories
   {
     sealed case class Args(
-      session_id: UUID,
+      session_id: UUID.T,
       theories: List[String],
       master_dir: String = "",
       pretty_margin: Double = Pretty.default_margin,
       unicode_symbols: Boolean = false,
       export_pattern: String = "",

           nodes_status_delay = nodes_status_delay)
       }
 
     def command(args: Args,
       session: Headless.Session,
-      id: UUID = UUID(),
+      id: UUID.T = UUID.random(),
       progress: Progress = No_Progress): (JSON.Object.T, Headless.Use_Theories_Result) =
     {
       val result =
         session.use_theories(args.theories, master_dir = args.master_dir,
           check_delay = args.check_delay, check_limit = args.check_limit,

   }
 
   object Purge_Theories
   {
     sealed case class Args(
-      session_id: UUID,
+      session_id: UUID.T,
       theories: List[String] = Nil,
       master_dir: String = "",
       all: Boolean = false)
 
     def unapply(json: JSON.T): Option[Args] =