Resolve nested callable references in manager term configs (#7513)

## Description

After a Hydra / `from_dict()` round-trip, callable references nested
outside `ManagerTermBaseCfg.params` can remain lazy string values.
Observation modifiers are stored in `ObservationTermCfg.modifiers`, so
the existing parameter recursion never reaches `ModifierCfg.func` before
`ObservationManager` performs class detection and signature validation.

This change extends the existing `ManagerBase._resolve_param_value`
recursion instead of adding another resolution path:

- `_process_term_cfg_at_play` walks every manager-term field rather than
only `params`
- `_resolve_param_value` traverses nested configuration dataclasses in
addition to its existing dict, list, tuple, and nested-term cases
- string-valued `func` fields are resolved at that single point
- the root term uses the same resolver before its own signature
validation
- production code does not inspect or depend on the `ResolvableString`
type
- `ObservationManager`, `ModifierCfg`, and existing `params` forwarding
behavior remain unchanged

The modifier documentation now reflects the existing contract: function
modifiers use `params` for call-time keyword arguments, while stateful
class modifiers keep constructor settings on dedicated `ModifierCfg`
subclasses.

No second recursive walker, `class_type`, wrapper configuration,
modifier dispatch branch, or callable-proxy introspection behavior is
introduced.

## Release backport

- [x] <!-- backport-active-release --> This PR already targets the
active release branch; do not backport it again.

## Tests

- Added an end-to-end observation modifier round-trip regression using a
dedicated stateful modifier config and empty call-time `params`
- Added a manager-level regression proving runtime traversal reaches
term fields outside `params`
- 92 focused manager, modifier, config, dictionary, and string tests
passed
- Formatting, lint, security, and RST checks passed
- Changelog validation passed against the current upstream `develop`

Fixes #6067

Author: ooctipus

source/isaaclab/changelog.d/resolvable-string-modifier.rst

@@ -0,0 +1,4 @@
+Fixed
+^^^^^
+
+* Fixed function and class-based observation modifiers failing after a configuration dictionary round-trip.

source/isaaclab/isaaclab/managers/manager_base.py

@@ -10,11 +10,13 @@
 import weakref
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
+from dataclasses import fields
 from typing import TYPE_CHECKING, Any
 
 import isaaclab.utils.string as string_utils
 from isaaclab.physics import PhysicsEvent, PhysicsManager
 from isaaclab.utils import class_to_dict, string_to_callable
+from isaaclab.utils.modifiers import ModifierCfg
 
 from .manager_term_cfg import ManagerTermBaseCfg
 from .scene_entity_cfg import SceneEntityCfg
@@ -334,8 +336,7 @@ def _resolve_common_term_cfg(self, term_name: str, term_cfg: ManagerTermBaseCfg,
             )
 
         # get the corresponding function or functional class
-        if isinstance(term_cfg.func, str):
-            term_cfg.func = string_to_callable(term_cfg.func)
+        term_cfg.func = self._resolve_param_value(term_name, "func", term_cfg.func, resolve_callable=True)
         # check if function is callable
         if not callable(term_cfg.func):
             raise AttributeError(f"The term '{term_name}' is not callable. Received: {term_cfg.func}")
@@ -381,7 +382,7 @@ def _process_term_cfg_at_play(self, term_name: str, term_cfg: ManagerTermBaseCfg
         This function is called when the simulation starts playing. It is used to process the term
         configuration at runtime. This includes:
 
-        * Resolving the scene entity configuration for the term.
+        * Resolving scene entity configurations and nested terms throughout the term configuration.
         * Initializing the term if it is a class.
 
         Since the above steps rely on PhysX to parse over the simulation scene, they are deferred
@@ -391,27 +392,49 @@ def _process_term_cfg_at_play(self, term_name: str, term_cfg: ManagerTermBaseCfg
             term_name: The name of the term.
             term_cfg: The term configuration.
         """
-        for key, value in term_cfg.params.items():
-            self._resolve_param_value(term_name, key, value)
+        for field in fields(term_cfg):
+            value = getattr(term_cfg, field.name)
+            resolved_value = self._resolve_param_value(
+                term_name, field.name, value, resolve_callable=field.name == "func"
+            )
+            if resolved_value is not value:
+                setattr(term_cfg, field.name, resolved_value)
 
-        # resolve string func references then initialize class-based terms
-        if isinstance(term_cfg.func, str):
-            term_cfg.func = string_to_callable(term_cfg.func)
+        # initialize class-based terms
         if inspect.isclass(term_cfg.func):
             term_cfg.func = term_cfg.func(cfg=term_cfg, env=self._env)
 
-    def _resolve_param_value(self, term_name: str, key: str | int, value: Any):
-        """Recursively resolve a single param value (SceneEntityCfg, nested term cfgs, dicts, lists)."""
+    def _resolve_param_value(
+        self, term_name: str, key: str | int, value: Any, *, resolve_callable: bool = False
+    ) -> Any:
+        """Recursively resolve manager-owned values in a term configuration."""
+        if resolve_callable and isinstance(value, str):
+            return string_to_callable(value)
         if isinstance(value, SceneEntityCfg):
             try:
                 value.resolve(self._env.scene)
             except ValueError as e:
                 raise ValueError(f"Error while parsing '{term_name}:{key}'. {e}")
         elif isinstance(value, ManagerTermBaseCfg):
             self._process_term_cfg_at_play(f"{term_name}.{key}", value)
+        elif isinstance(value, ModifierCfg):
+            for field in fields(value):
+                field_value = getattr(value, field.name)
+                resolved_value = self._resolve_param_value(
+                    f"{term_name}.{key}", field.name, field_value, resolve_callable=field.name == "func"
+                )
+                if resolved_value is not field_value:
+                    setattr(value, field.name, resolved_value)
         elif isinstance(value, dict):
             for sub_key, sub_value in value.items():
-                self._resolve_param_value(f"{term_name}.{key}", sub_key, sub_value)
-        elif isinstance(value, (list, tuple)):
+                value[sub_key] = self._resolve_param_value(f"{term_name}.{key}", sub_key, sub_value)
+        elif isinstance(value, list):
             for i, item in enumerate(value):
-                self._resolve_param_value(f"{term_name}.{key}", i, item)
+                value[i] = self._resolve_param_value(f"{term_name}.{key}", i, item)
+        elif isinstance(value, tuple):
+            resolved_items = tuple(
+                self._resolve_param_value(f"{term_name}.{key}", i, item) for i, item in enumerate(value)
+            )
+            if any(resolved is not original for resolved, original in zip(resolved_items, value, strict=True)):
+                value = resolved_items
+        return value

source/isaaclab/isaaclab/managers/observation_manager.py

@@ -396,7 +396,10 @@ def compute_group(self, group_name: str, update_history: bool = False) -> torch.
             # apply post-processing
             if term_cfg.modifiers is not None:
                 for modifier in term_cfg.modifiers:
-                    obs = modifier.func(obs, **modifier.params)
+                    if isinstance(modifier.func, modifiers.ModifierBase):
+                        obs = modifier.func(obs)
+                    else:
+                        obs = modifier.func(obs, **modifier.params)
             if isinstance(term_cfg.noise, noise.NoiseCfg):
                 obs = term_cfg.noise.func(obs, term_cfg.noise)
             elif isinstance(term_cfg.noise, noise.NoiseModelCfg) and term_cfg.noise.func is not None:
@@ -579,25 +582,22 @@ def _prepare_terms(self):
                 if term_cfg.modifiers is not None:
                     # initialize list of modifiers for term
                     for mod_cfg in term_cfg.modifiers:
-                        # check if class modifier and initialize with observation size when adding
-                        if isinstance(mod_cfg, modifiers.ModifierCfg):
-                            # to list of modifiers - instantiate class-based modifiers
-                            if inspect.isclass(mod_cfg.func):
-                                mod_cfg.func = mod_cfg.func(cfg=mod_cfg, data_dim=obs_dims, device=self._env.device)
-                                # verify the instance is the correct type
-                                if not isinstance(mod_cfg.func, modifiers.ModifierBase):
-                                    raise TypeError(
-                                        f"Modifier function '{mod_cfg.func}' for observation term '{term_name}'"
-                                        f" is not an instance of 'ModifierBase'. Received: '{type(mod_cfg.func)}'."
-                                    )
-                                # add to list of class modifiers
-                                self._group_obs_class_instances.append(mod_cfg.func)
-                        else:
+                        if not isinstance(mod_cfg, modifiers.ModifierCfg):
                             raise TypeError(
                                 f"Modifier configuration '{mod_cfg}' of observation term '{term_name}' is not of"
                                 f" required type ModifierCfg, Received: '{type(mod_cfg)}'"
                             )
 
+                        # construct stateful modifiers with the observation size
+                        if inspect.isclass(mod_cfg.func):
+                            mod_cfg.func = mod_cfg.func(cfg=mod_cfg, data_dim=obs_dims, device=self._env.device)
+                            if not isinstance(mod_cfg.func, modifiers.ModifierBase):
+                                raise TypeError(
+                                    f"Modifier function '{mod_cfg.func}' for observation term '{term_name}'"
+                                    f" is not an instance of 'ModifierBase'. Received: '{type(mod_cfg.func)}'."
+                                )
+                            self._group_obs_class_instances.append(mod_cfg.func)
+
                         # check if function is callable
                         if not callable(mod_cfg.func):
                             raise AttributeError(

source/isaaclab/isaaclab/utils/modifiers/modifier_cfg.py

@@ -3,35 +3,38 @@
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
+from __future__ import annotations
+
 from collections.abc import Callable
 from dataclasses import MISSING
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import torch
 
 from isaaclab.utils.configclass import configclass
 
-from . import modifier
+if TYPE_CHECKING:
+    from .modifier import DigitalFilter, Integrator
+    from .modifier_base import ModifierBase
 
 
 @configclass
 class ModifierCfg:
-    """Configuration parameters modifiers"""
-
-    func: Callable[..., torch.Tensor] = MISSING
-    """Function or callable class used by modifier.
+    """Configuration parameters for function and class modifiers."""
 
-    The function must take a torch tensor as the first argument. The remaining arguments are specified
-    in the :attr:`params` attribute.
+    func: Callable[..., torch.Tensor] | type[ModifierBase] | str = MISSING
+    """Function or :class:`ModifierBase` class used by the modifier.
 
-    It also supports `callable classes <https://docs.python.org/3/reference/datamodel.html#object.__call__>`_,
-    i.e. classes that implement the ``__call__()`` method. In this case, the class should inherit from the
-    :class:`ModifierBase` class and implement the required methods.
+    Functions must take a tensor as their first argument. Classes must inherit from :class:`ModifierBase`; the
+    observation manager constructs them with the configuration, observation dimensions, and device.
     """
 
     params: dict[str, Any] = dict()
-    """The parameters to be passed to the function or callable class as keyword arguments. Defaults to
-    an empty dictionary."""
+    """Parameters used by the modifier. Defaults to an empty dictionary.
+
+    Function modifiers receive them as keyword arguments on each call. Class modifiers access them through this
+    configuration during construction; they are not forwarded to the constructed instance.
+    """
 
 
 @configclass
@@ -41,7 +44,7 @@ class DigitalFilterCfg(ModifierCfg):
     For more information, please check the :class:`DigitalFilter` class.
     """
 
-    func: type[modifier.DigitalFilter] = modifier.DigitalFilter
+    func: type[DigitalFilter] | str = "{DIR}.modifier:DigitalFilter"
     """The digital filter function to be called for applying the filter."""
 
     A: list[float] = MISSING
@@ -72,7 +75,7 @@ class IntegratorCfg(ModifierCfg):
     For more information, please check the :class:`Integrator` class.
     """
 
-    func: type[modifier.Integrator] = modifier.Integrator
+    func: type[Integrator] | str = "{DIR}.modifier:Integrator"
     """The integrator function to be called for applying the integrator."""
 
     dt: float = MISSING

source/isaaclab/test/managers/test_manager_base.py

@@ -6,7 +6,7 @@
 # ignore private usage of variables warning
 # pyright: reportPrivateUsage=none
 
-"""Tests for recursive _process_term_cfg_at_play / _resolve_param_value.
+"""Tests for recursive manager term configuration resolution.
 
 These tests exercise ManagerBase's parameter resolution logic and do NOT
 require an Isaac Sim launch, so they can run without AppLauncher.
@@ -22,6 +22,8 @@
 from isaaclab.envs import ManagerBasedEnv
 from isaaclab.managers import ManagerTermBase, ManagerTermBaseCfg
 from isaaclab.managers.manager_base import ManagerBase
+from isaaclab.utils import modifiers
+from isaaclab.utils.configclass import configclass
 
 pytestmark = pytest.mark.integration
 
@@ -69,6 +71,23 @@ def reset_dummy2_to_zero(env, env_ids: torch.Tensor):
     env.dummy2[env_ids] = 0
 
 
+@configclass
+class OpaqueCfg:
+    """Configuration that is outside ``ManagerBase`` ownership."""
+
+    func: str = f"{__name__}:reset_dummy2_to_zero"
+
+
+@configclass
+class NestedFieldTermCfg(ManagerTermBaseCfg):
+    """Manager term with owned and opaque fields outside ``params``."""
+
+    nested_term: ManagerTermBaseCfg = ManagerTermBaseCfg(func=increment_dummy1_by_one)
+    modifier: modifiers.ModifierCfg = modifiers.ModifierCfg(func=increment_dummy1_by_one)
+    metadata: dict[str, str] = {"func": f"{__name__}:reset_dummy2_to_zero"}
+    opaque: OpaqueCfg = OpaqueCfg()
+
+
 class reset_dummy2_to_zero_class(ManagerTermBase):
     def __init__(self, cfg: ManagerTermBaseCfg, env: ManagerBasedEnv):
         super().__init__(cfg, env)
@@ -217,6 +236,24 @@ def test_string_func_in_nested_term_cfg(env):
     torch.testing.assert_close(env.dummy1, 11 * torch.ones_like(env.dummy1))
 
 
+def test_resolution_walks_declared_term_fields_outside_params(env):
+    """Resolve nested term and modifier callables without interpreting arbitrary ``func`` keys."""
+    outer_cfg = NestedFieldTermCfg(
+        func=increment_dummy1_by_one,
+        nested_term=ManagerTermBaseCfg(func=f"{__name__}:reset_dummy2_to_zero"),
+    )
+    outer_cfg.from_dict(outer_cfg.to_dict())
+    cfg = {"outer": outer_cfg}
+    manager = SimpleManager(cfg, env)
+
+    term_cfg = manager._term_cfgs[0][1]
+    assert isinstance(term_cfg, NestedFieldTermCfg)
+    assert term_cfg.nested_term.func is reset_dummy2_to_zero
+    assert term_cfg.modifier.func is increment_dummy1_by_one
+    assert isinstance(term_cfg.metadata["func"], str)
+    assert isinstance(term_cfg.opaque.func, str)
+
+
 def test_string_func_top_level_class_term(env):
     """Test that a top-level string-based func pointing to a class is properly instantiated."""
     this_module = __name__

source/isaaclab/test/managers/test_observation_manager_unit.py

@@ -9,12 +9,14 @@
 
 # ignore private usage of variables warning
 # pyright: reportPrivateUsage=none
+import inspect
 from typing import TYPE_CHECKING, cast
 
 import pytest
 import torch
 
 from isaaclab.managers import ObservationGroupCfg, ObservationManager, ObservationTermCfg
+from isaaclab.utils import modifiers
 from isaaclab.utils.configclass import configclass
 
 pytestmark = pytest.mark.unit
@@ -46,6 +48,28 @@ def __init__(self, num_envs: int = 2) -> None:
         self.observation = torch.arange(num_envs, dtype=torch.float32).unsqueeze(-1)
 
 
+class StatefulBiasModifier(modifiers.ModifierBase):
+    """Stateful modifier used to verify lazy callable resolution."""
+
+    def __init__(self, cfg: modifiers.ModifierCfg, data_dim: tuple[int, ...], device: str) -> None:
+        super().__init__(cfg, data_dim, device)
+        self.value = cfg.params["value"]
+        self.reset_count = 0
+
+    def reset(self, env_ids=None) -> None:
+        self.reset_count += 1
+
+    def __call__(self, data: torch.Tensor) -> torch.Tensor:
+        return data + self.value
+
+
+class InvalidModifier:
+    """Class with the modifier constructor contract but the wrong base type."""
+
+    def __init__(self, cfg, data_dim, device):
+        pass
+
+
 @configclass
 class HistoryObservationsCfg:
     """Observation configuration with group-level history."""
@@ -62,6 +86,68 @@ def __post_init__(self):
     policy: PolicyCfg = PolicyCfg()
 
 
+def test_class_modifier_roundtrip_preserves_func_and_params():
+    """Reproduce #6067 with a class modifier and non-empty parameters."""
+    cfg = HistoryObservationsCfg()
+    cfg.policy.history_length = None
+    cfg.policy.dummy.modifiers = [modifiers.ModifierCfg(func=StatefulBiasModifier, params={"value": 2.0})]
+    cfg.from_dict(cfg.to_dict())
+    term_cfg = cfg.policy.dummy
+    assert term_cfg.modifiers is not None
+    modifier_cfg = term_cfg.modifiers[0]
+    assert isinstance(modifier_cfg, modifiers.ModifierCfg)
+    assert isinstance(modifier_cfg.func, str)
+    assert modifier_cfg.params == {"value": 2.0}
+
+    env = DummyEnv()
+    manager = ObservationManager(cfg, cast("ManagerBasedEnv", env))
+    prepared_term_cfg = manager.cfg.policy.dummy
+    assert prepared_term_cfg.modifiers is not None
+    prepared_modifier_cfg = prepared_term_cfg.modifiers[0]
+    assert isinstance(prepared_modifier_cfg.func, StatefulBiasModifier)
+    observations = manager.compute()["policy"]
+    torch.testing.assert_close(observations, env.observation + 2.0)
+
+    manager.reset()
+    assert prepared_modifier_cfg.func.reset_count == 1
+
+
+def test_stateless_modifier_cfg_roundtrip_preserves_signature_validation():
+    """A stateless modifier remains callable and inspectable after a configuration round-trip."""
+    cfg = HistoryObservationsCfg()
+    cfg.policy.history_length = None
+    cfg.policy.dummy.modifiers = [modifiers.ModifierCfg(func=modifiers.bias, params={"value": 2.0})]
+    cfg.from_dict(cfg.to_dict())
+
+    env = DummyEnv()
+    manager = ObservationManager(cfg, cast("ManagerBasedEnv", env))
+    observations = manager.compute()["policy"]
+    torch.testing.assert_close(observations, env.observation + 2.0)
+
+
+def test_class_modifier_validates_constructed_instance():
+    """Class modifier validation checks the constructed object."""
+    cfg = HistoryObservationsCfg()
+    cfg.policy.history_length = None
+    cfg.policy.dummy.modifiers = [modifiers.ModifierCfg(func=InvalidModifier)]
+    cfg.from_dict(cfg.to_dict())
+
+    with pytest.raises(TypeError, match="is not an instance of 'ModifierBase'"):
+        ObservationManager(cfg, cast("ManagerBasedEnv", DummyEnv()))
+
+
+def test_modifier_resolution_stays_out_of_observation_manager():
+    """Observation-specific code receives resolved modifier callables from ``ManagerBase``."""
+    source = inspect.getsource(ObservationManager._prepare_terms)
+    assert "inspect.isclass(mod_cfg.func)" in source
+    assert "string_to_callable" not in source
+
+
+def test_modifier_base_cfg_marker_does_not_exist():
+    """Stateful modifiers must not require a marker configuration subtype."""
+    assert not hasattr(modifiers, "ModifierBaseCfg")
+
+
 def test_compute_updates_history_only_when_requested():
     """Observation history changes only when ``update_history`` is enabled."""
     env = DummyEnv()