Fix is_monolithic missing when setting VLLM_FL_PREFER_ENABLED=0 (#252)

### PR Category
Core
### PR Type
Bug Fixes
### Description
fix is_monolithic missing when setting VLLM_FL_PREFER_ENABLED=0

```
  Root cause chain:

  is_out_of_tree() _ True (PlatformFL)
      _
  select_unquantized_moe_backend() returns (OOT, None)
      _
  experts_cls = None
      _
  code calls experts_cls.is_monolithic _ AttributeError: NoneType has no attribute 'is_monolithic'

  The upstream function has this logic:

  if current_platform.is_out_of_tree():
      return UnquantizedMoeBackend.OOT, None  # _ expects OOT PluggableLayer to handle it

  When FusedMoEFL is registered, vLLM never reaches this code path (it uses FusedMoEFL's own method). But when FusedMoEFL is not registered (disabled/blacklisted), vLLM falls through to the
  built-in FusedMoE, which calls select_unquantized_moe_backend(). Since PlatformFL still reports is_out_of_tree() _ True, it returns (OOT, None) and blows up.
```

---------

Co-authored-by: ceci3 <ceci3@users.noreply.github.com>

Author: cyber-pioneer

vllm_fl/__init__.py

@@ -128,6 +128,9 @@ def register_router():
     # fused_moe import chain triggers cutlass_scaled_mm_supports_fp8 on MUSA
     if current_platform.device_type == "musa":
         return
+    from vllm_fl.utils import is_oot_enabled
+    if not is_oot_enabled():
+        return
     from vllm_fl.ops.fused_moe.router import replace_router_with_fl
     replace_router_with_fl()
 

vllm_fl/ops/custom_ops.py

@@ -29,6 +29,26 @@
     ),
 }
 
+def _patch_unquantized_moe_oracle() -> None:
+    """
+    Monkey-patch the upstream select_unquantized_moe_backend so it does not
+    short-circuit to (OOT, None) on our platform.  Instead it falls through
+    to the normal CUDA/ROCm backend priority selection — the same logic that
+    select_unquantized_moe_backend_oot uses.
+
+    This is needed when FusedMoEFL is NOT registered (PREFER_ENABLED=0 or
+    fused_moe blacklisted): without the patch, the in-tree UnquantizedFusedMoEMethod
+    would get (OOT, None), skip _setup_kernel, and crash at inference time.
+    """
+    import vllm.model_executor.layers.fused_moe.oracle.unquantized as _oracle_mod
+    from vllm_fl.ops.fused_moe.fused_moe_utils import select_unquantized_moe_backend_oot
+    _oracle_mod.select_unquantized_moe_backend = select_unquantized_moe_backend_oot
+    # Also patch the import in unquantized_fused_moe_method module
+    import vllm.model_executor.layers.fused_moe.unquantized_fused_moe_method as _method_mod
+    _method_mod.select_unquantized_moe_backend = select_unquantized_moe_backend_oot
+    logger.info("Patched select_unquantized_moe_backend to bypass OOT short-circuit")
+
+
 def register_oot_ops(whitelist: Optional[List[str]] = None) -> None:
     """
     Register OOT (out-of-tree) custom operators.
@@ -40,11 +60,17 @@ def register_oot_ops(whitelist: Optional[List[str]] = None) -> None:
 
     Operators in VLLM_FL_OOT_BLACKLIST or platform config oot_blacklist
     will be excluded from registration.
+
+    When fused_moe is not registered (PREFER_ENABLED=0 or blacklisted),
+    the upstream select_unquantized_moe_backend oracle is monkey-patched
+    so it picks native CUDA backends instead of returning (OOT, None).
     """
     from vllm_fl.utils import get_oot_blacklist, get_oot_whitelist, is_oot_enabled, use_flaggems_op
 
     # Check if OOT registration is enabled
     if not is_oot_enabled():
+        # Patch the upstream oracle so in-tree FusedMoE works on this platform.
+        _patch_unquantized_moe_oracle()
         return
 
     # Get blacklist (from env var or platform config)
@@ -62,6 +88,11 @@ def register_oot_ops(whitelist: Optional[List[str]] = None) -> None:
     # Apply blacklist
     ops_to_register = [op for op in ops_to_register if op not in blacklist]
 
+    # If fused_moe is excluded (blacklisted or not in whitelist), patch the
+    # upstream oracle so the in-tree FusedMoE doesn't crash on OOT platforms.
+    if "fused_moe" not in ops_to_register:
+        _patch_unquantized_moe_oracle()
+
     for op_name in ops_to_register:
         if op_name not in OOT_OPS:
             logger.warning(f"OOT op '{op_name}' not found in OOT_OPS, skipping.")