Update factory/world_factory.py

factory/world_factory.py

@@ -473,7 +473,28 @@ class WorldFactory:
         owner_agent_id: str | None = None,
         behavior_index: int | None = None,
     ) -> Behavior:
-        """Create a runtime behavior object from a ``BehaviorSpec``."""
+        """Create a runtime behavior object from a ``BehaviorSpec``.
+
+        The DSL behavior spec has this shape:
+
+            {"name": "attack", "params": {...}}
+
+        Runtime behavior objects should receive a deterministic runtime id, but
+        the DSL behavior name should not be passed as a constructor argument named
+        ``name`` because many behavior classes expose ``name`` as a read-only or
+        class-level registry attribute.
+
+        This method supports both behavior implementation styles used in the
+        codebase:
+
+        1. Newer dataclass-style behaviors that accept params directly as
+        constructor kwargs.
+
+        2. Rich core.behavior-style behaviors that expect:
+            Behavior(id="...", parameters={...})
+
+        The second form is especially important for rich movement/conflict modules.
+        """
 
         target = self._resolve_registry_item(
             registry=self._behavior_registry,
@@ -489,31 +510,94 @@ class WorldFactory:
             behavior_index=behavior_index,
         )
 
-        params = copy.deepcopy(spec.params)
-        params.setdefault("id", runtime_behavior_id)
-
-        behavior = self._instantiate_runtime_object(
-            target,
-            params,
-            aliases={},
-            strict=self.config.strict_constructor_params,
-            path=f"behavior:{spec.name}.params",
-            item_kind="behavior",
+        raw_params = copy.deepcopy(spec.params)
+
+        constructor_attempts: tuple[tuple[str, dict[str, Any], bool], ...] = (
+            (
+                "direct_params",
+                {
+                    **copy.deepcopy(raw_params),
+                    "id": runtime_behavior_id,
+                },
+                self.config.strict_constructor_params,
+            ),
+            (
+                "parameters_dict",
+                {
+                    "id": runtime_behavior_id,
+                    "parameters": copy.deepcopy(raw_params),
+                },
+                False,
+            ),
+            (
+                "behavior_id_parameters_dict",
+                {
+                    "behavior_id": runtime_behavior_id,
+                    "parameters": copy.deepcopy(raw_params),
+                },
+                False,
+            ),
         )
 
+        behavior: Any | None = None
+        attempt_errors: list[str] = []
+
+        for attempt_name, attempt_params, strict in constructor_attempts:
+            try:
+                behavior = self._instantiate_runtime_object(
+                    target,
+                    attempt_params,
+                    aliases={},
+                    strict=strict,
+                    path=f"behavior:{spec.name}.params",
+                    item_kind="behavior",
+                )
+                break
+            except Exception as exc:
+                attempt_errors.append(
+                    f"{attempt_name}: {exc.__class__.__name__}: {exc}"
+                )
+                logger.debug(
+                    "Behavior construction attempt failed for behavior=%s attempt=%s",
+                    spec.name,
+                    attempt_name,
+                    exc_info=True,
+                )
+
+        if behavior is None:
+            raise RuntimeObjectBuildError(
+                "Could not instantiate behavior "
+                f"{spec.name!r} after {len(constructor_attempts)} constructor attempt(s). "
+                f"Attempt errors: {attempt_errors}"
+            )
+
         if not isinstance(behavior, Behavior) and not callable(getattr(behavior, "execute", None)):
             raise RuntimeObjectBuildError(
                 f"Behavior {spec.name!r} did not produce an executable behavior object"
             )
 
         self._safe_setattr(behavior, "id", runtime_behavior_id)
+        self._safe_setattr(behavior, "behavior_id", runtime_behavior_id)
+
+        # Do not require this to succeed. Some behavior classes expose ``name`` as
+        # a read-only/class-level registry attribute.
         self._safe_setattr(behavior, "name", spec.name)
+
+        # These are safe diagnostics/metadata attachments. They may fail on highly
+        # slotted/frozen classes, so _safe_setattr intentionally does not raise.
         self._safe_setattr(behavior, "enabled", bool(spec.enabled))
         self._safe_setattr(behavior, "priority", float(spec.priority))
         self._safe_setattr(behavior, "tags", tuple(spec.tags))
         self._safe_setattr(behavior, "metadata", copy.deepcopy(spec.metadata))
         self._safe_setattr(behavior, "dsl_spec", spec)
 
+        # Rich behavior modules such as movement.py and attack.py use
+        # ``self.parameters`` internally. Preserve the original DSL params there
+        # whenever the object supports it.
+        existing_parameters = getattr(behavior, "parameters", None)
+        if not isinstance(existing_parameters, Mapping) or not existing_parameters:
+            self._safe_setattr(behavior, "parameters", copy.deepcopy(raw_params))
+
         return behavior
 
     def create_policy_for_agent(self, agent_spec: AgentSpec) -> BasePolicy | None: