Use Console Entries to Drive Class Presets
You can look at the context.window_manager.operators collection.  The property settings are in the properties collection.  items(...) returns a list of key, value pairs

setattr(op, key, value)
# a key value pair of ("width", 3)
#equivalent of
op.width = 3


Put this in a draw method and it will list all operators by name, and if it's a bevel op expand on the call method as seen in the INFO panel and list the key value pairs.

    box = layout.box()
    for o in context.window_manager.operators:
        row = box.row()
        row.label(text=o.name)
        if o.name == 'Bevel':
            bbox = box.box()
            row = bbox.row()
            row.label(text="bpy.ops.mesh.bevel(%s)" % ", "
                     .join(["%s=%s" % (k, str(v)) 
                            for k, v in o.properties.items()]))
            for k, v in o.properties.items():
                row = bbox.row()
                row.label(text="%s = %s" % (k, str(v))) 


Here is a modal timer operator that captures the bevel operator properties once it becomes context.active_operator to do something while it is happening.
(Test Code)

Put your mesh into edit mode, then run the operator, the operator will cancel when the user leaves edit mode, this can be changed.

Whenever a bevel operator is used it saves the settings to a dictionary on the operator, and while a bevel operator is context.active_operator prints the settings to the system console.

import bpy


class ModalTimerOperator(bpy.types.Operator):
    """Operator which runs its self from a timer"""
    bl_idname = "wm.modal_timer_operator"
    bl_label = "Modal Timer Operator"

    _timer = None
    bevel_operators = {}

    def modal(self, context, event):
        if context.mode != 'EDIT_MESH':
            self.cancel(context)
            return {'CANCELLED'}


        if event.type == 'TIMER':

            op = context.active_operator
            if op is None:
                return {'PASS_THROUGH'}

            if op.name == 'CSharpen':
                op.bevelwidth += 0.01
                if not op.run_modal:
                    #cancelled from CSharpen Operator update prop
                    self.cancel(context)
                    return {'CANCELLED'}

            elif op.name == "Bevel": # op.rna_type.identifier == "MESH_OT_bevel":
                key = hash(op)
                # save the operator props in a dictionary
                print("BEVEL", len(self.bevel_operators))
                print("bpy.ops.mesh.bevel(%s)" % " ,".join(["%s=%s" % (k, str(v)) for k, v in op.properties.items()]))   
                self.bevel_operators.setdefault(key, 
                                     {k:v for k,v in op.properties.items()})


        return {'PASS_THROUGH'}

    def execute(self, context):
        wm = context.window_manager
        self._timer = wm.event_timer_add(0.1, context.window)
        wm.modal_handler_add(self)
        return {'RUNNING_MODAL'}

    def cancel(self, context):
        print("Operator Cancelled")
        wm = context.window_manager
        wm.event_timer_remove(self._timer)
        # perform pre cancel here
        # print out the bevel operator dic

        for h, bo in self.bevel_operators.items():
            print(h, bo)


def register():
    bpy.utils.register_class(ModalTimerOperator)


def unregister():
    bpy.utils.unregister_class(ModalTimerOperator)


if __name__ == "__main__":
    register()

    # test call
    bpy.ops.wm.modal_timer_operator()


from code I set up from another answer to you where this operator talks to that operator "Csharpen"