feat: improve GeniusNegotiator None offer handling and add Scenario.stability

GeniusNegotiator improvements:
- Add none_offer_response parameter ("latest" or "best")
- New on_none_offer() method for customizable None offer handling
- Remove blanket rejection of mechanisms with allow_none_with_data

Scenario stability:
- Add stability property returning combined stability of all ufuns
- Add convenience methods: is_volatile(), is_stationary(), etc.
- Add has_stable_min, has_stable_max, has_stable_ordering properties

Tests:
- Add comprehensive ExtendedOutcome tests in test_outcome_space.py

Author: yasserfarouk

src/negmas/genius/negotiator.py

@@ -62,6 +62,10 @@ class GeniusNegotiator(SAONegotiator):
                 If false, ignore these exceptions and assume a None return.
                 If None use strict for n_steps limited negotiations and not strict for time_limit
                 limited ones.
+        none_offer_response: How to respond when receiving a None offer. Options are:
+                - "latest": Respond with the latest offer made by this negotiator (default)
+                - "best": Respond with the best offer according to this negotiator's ufun
+                If "latest" is selected but no previous offer exists, falls back to "best".
     """
 
     def __init__(
@@ -78,6 +82,7 @@ def __init__(
         port: int = DEFAULT_JAVA_PORT,
         genius_bridge_path: str | None = None,
         strict: bool | None = None,
+        none_offer_response: str = "latest",
         id: str | None = None,
         **kwargs,
     ):
@@ -89,6 +94,7 @@ def __init__(
         self.__destroyed = False
         self.__started = False
         self._strict = strict
+        self._none_offer_response = none_offer_response
         self.capabilities["propose"] = can_propose
         self.add_capabilities({"genius": True})
         self.genius_bridge_path = (
@@ -300,20 +306,12 @@ def join(
 
         Returns:
             True if successfully joined, False otherwise
-
-        Raises:
-            ValueError: If the mechanism allows None offers (allow_none_with_data=True),
-                       which Genius negotiators cannot handle.
         """
         if ufun:
             preferences = ufun
         if not preferences:
             preferences = self.__preferences_received
 
-        # Check if the mechanism allows None offers - Genius negotiators cannot handle this
-        if hasattr(nmi, "allow_none_with_data") and nmi.allow_none_with_data:
-            return False
-
         result = super().join(
             nmi=nmi, state=state, preferences=preferences, ufun=None, role=role
         )
@@ -731,6 +729,26 @@ def _current_step(self, state):
             s = int(s / self.nmi.n_negotiators)
         return s
 
+    def on_none_offer(self, state: SAOState, source: str | None = None) -> SAOResponse:
+        """
+        Called when the negotiator receives a None offer.
+
+        Override this method to customize behavior when a None offer is received.
+        The default implementation uses `none_offer_response` setting to decide
+        whether to respond with the latest offer or the best offer.
+
+        Args:
+            state: The current SAO negotiation state
+            source: The ID of the negotiator who made the None offer
+
+        Returns:
+            SAOResponse with the action and offer to respond with
+        """
+        if self._none_offer_response == "latest" and self.__my_last_offer is not None:
+            return SAOResponse(ResponseType.REJECT_OFFER, self.__my_last_offer)
+        # Fall back to best offer (via propose_sao which queries Java agent)
+        return self.propose_sao(state, source)
+
     def respond_sao(self, state: SAOState, source: str | None = None) -> None:
         """
         Processes an incoming offer and prepares a response for SAO mechanisms.
@@ -743,8 +761,10 @@ def respond_sao(self, state: SAOState, source: str | None = None) -> None:
         if offer is None and self.__my_last_offer is not None and self._strict:
             raise ValueError(f"{self._me()} got counter with a None offer.")
         if offer is None:
-            # TODO: change this to use the correct source if multilateral negotiation
-            self.propose_sao(state, source)
+            response = self.on_none_offer(state, source)
+            self.__my_last_offer = response.outcome
+            self.__my_last_response = response.response
+            self.__my_last_offer_step = self._current_step(state)
             return
         proposer_id = self.nmi.genius_id(state.current_proposer)
         current_step = self._current_step(state)

src/negmas/inout.py

@@ -46,6 +46,8 @@
     opposition_level,
     pareto_frontier,
     winwin_level,
+    Stability,
+    STATIONARY,
 )
 from .preferences.value_fun import TableFun
 
@@ -165,6 +167,75 @@ def is_linear_ufun(ufun: BaseUtilityFunction) -> bool:
 
         return all(is_linear_ufun(u) for u in self.ufuns)
 
+    @property
+    def stability(self) -> Stability:
+        """Returns the combined stability of all utility functions in the scenario.
+
+        The combined stability is the bitwise AND of all ufun stabilities, meaning
+        a flag is only set if ALL ufuns have that flag set.
+
+        Returns:
+            Stability flags that are common to all ufuns in the scenario.
+
+        Examples:
+            >>> from negmas import make_issue, Scenario
+            >>> from negmas.preferences import LinearUtilityFunction, STATIONARY
+            >>> issues = [make_issue([0, 1, 2], "x")]
+            >>> u1 = LinearUtilityFunction(weights=[1.0], issues=issues)
+            >>> u2 = LinearUtilityFunction(weights=[0.5], issues=issues)
+            >>> scenario = Scenario(outcome_space=make_os(issues), ufuns=(u1, u2))
+            >>> scenario.stability == STATIONARY
+            True
+        """
+        if not self.ufuns:
+            return STATIONARY
+        result = self.ufuns[0].stability
+        for ufun in self.ufuns[1:]:
+            result = Stability(int(result) & int(ufun.stability))
+        return result
+
+    def is_volatile(self) -> bool:
+        """Check if the scenario is volatile (any ufun has no stability guarantees).
+
+        Returns True if the combined stability is VOLATILE (value = 0).
+        """
+        return self.stability.is_volatile
+
+    def is_stationary(self) -> bool:
+        """Check if all ufuns in the scenario are fully stationary.
+
+        Returns True only if ALL ufuns have ALL stability flags set.
+        """
+        return self.stability.is_stationary
+
+    def is_session_dependent(self) -> bool:
+        """Check if any ufun depends on session details (NMI)."""
+        return self.stability.is_session_dependent
+
+    def is_state_dependent(self) -> bool:
+        """Check if any ufun depends on state variables."""
+        return self.stability.is_state_dependent
+
+    @property
+    def has_stable_min(self) -> bool:
+        """Check if minimum utility is stable for all ufuns."""
+        return self.stability.has_stable_min
+
+    @property
+    def has_stable_max(self) -> bool:
+        """Check if maximum utility is stable for all ufuns."""
+        return self.stability.has_stable_max
+
+    @property
+    def has_stable_ordering(self) -> bool:
+        """Check if outcome ordering is stable for all ufuns."""
+        return self.stability.has_stable_ordering
+
+    @property
+    def has_stable_diff_ratios(self) -> bool:
+        """Check if relative utility differences are stable for all ufuns."""
+        return self.stability.has_stable_diff_ratios
+
     def plot(
         self,
         ufun_indices: tuple[int, int] | None = None,

tests/core/test_outcome_space.py

@@ -613,3 +613,223 @@ def test_singleton_os_repr_and_str(self):
 
         assert "1" in repr_str and "2" in repr_str
         assert "1" in str_str and "2" in str_str
+
+
+class TestExtendedOutcome:
+    """Tests for ExtendedOutcome class and best_for method."""
+
+    def test_extended_outcome_with_only_outcome(self):
+        """Test ExtendedOutcome with only an outcome."""
+        from negmas.outcomes.common import ExtendedOutcome
+
+        outcome = (5, 10)
+        extended = ExtendedOutcome(outcome=outcome)
+
+        assert extended.outcome == (5, 10)
+        assert extended.outcome_space is None
+        assert extended.data is None
+
+    def test_extended_outcome_with_outcome_and_data(self):
+        """Test ExtendedOutcome with outcome and data."""
+        from negmas.outcomes.common import ExtendedOutcome
+
+        outcome = (5, 10)
+        data = {"text": "My offer", "confidence": 0.9}
+        extended = ExtendedOutcome(outcome=outcome, data=data)
+
+        assert extended.outcome == (5, 10)
+        assert extended.data["text"] == "My offer"
+        assert extended.data["confidence"] == 0.9
+
+    def test_extended_outcome_with_outcome_space(self):
+        """Test ExtendedOutcome with only an outcome_space (multiple offers)."""
+        from negmas.outcomes.common import ExtendedOutcome
+
+        issues = [make_issue(5, name="price"), make_issue(3, name="quantity")]
+        os = make_os(issues)
+        extended = ExtendedOutcome(outcome=None, outcome_space=os)
+
+        assert extended.outcome is None
+        assert extended.outcome_space is os
+
+    def test_extended_outcome_with_both_outcome_and_outcome_space(self):
+        """Test ExtendedOutcome with both outcome and outcome_space."""
+        from negmas.outcomes.common import ExtendedOutcome
+
+        issues = [make_issue(5, name="price"), make_issue(3, name="quantity")]
+        os = make_os(issues)
+        outcome = (2, 1)
+        extended = ExtendedOutcome(outcome=outcome, outcome_space=os)
+
+        assert extended.outcome == (2, 1)
+        assert extended.outcome_space is os
+
+    def test_best_for_with_only_outcome(self):
+        """Test best_for returns the outcome when only outcome is set."""
+        from negmas.outcomes.common import ExtendedOutcome
+        from negmas.preferences import LinearUtilityFunction
+
+        issues = [make_issue(5, name="price"), make_issue(3, name="quantity")]
+        ufun = LinearUtilityFunction.random(issues=issues)
+
+        outcome = (2, 1)
+        extended = ExtendedOutcome(outcome=outcome)
+
+        result = extended.best_for(ufun)
+        assert result == outcome
+
+    def test_best_for_with_only_outcome_space(self):
+        """Test best_for returns the best outcome from outcome_space."""
+        from negmas.outcomes.common import ExtendedOutcome
+        from negmas.preferences import LinearUtilityFunction
+
+        issues = [make_issue(5, name="price"), make_issue(3, name="quantity")]
+        os = make_os(issues)
+        # Use positive weights so higher values are better
+        ufun = LinearUtilityFunction(weights=[1.0, 1.0], issues=issues)
+
+        extended = ExtendedOutcome(outcome=None, outcome_space=os)
+
+        result = extended.best_for(ufun)
+        # With positive weights, best outcome should be (4, 2) - max values
+        assert result == (4, 2)
+        # Verify it's actually the best
+        assert ufun(result) == ufun.max()
+
+    def test_best_for_with_both_outcome_and_outcome_space(self):
+        """Test best_for returns best from outcome_space when both are set."""
+        from negmas.outcomes.common import ExtendedOutcome
+        from negmas.preferences import LinearUtilityFunction
+
+        issues = [make_issue(5, name="price"), make_issue(3, name="quantity")]
+        os = make_os(issues)
+        # Use positive weights so higher values are better
+        ufun = LinearUtilityFunction(weights=[1.0, 1.0], issues=issues)
+
+        # outcome is NOT the best in the space
+        outcome = (1, 0)
+        extended = ExtendedOutcome(outcome=outcome, outcome_space=os)
+
+        result = extended.best_for(ufun)
+        # Should return best from outcome_space, not the provided outcome
+        assert result == (4, 2)
+        assert result != outcome
+
+    def test_best_for_with_none_outcome_and_none_space(self):
+        """Test best_for returns None when both outcome and outcome_space are None."""
+        from negmas.outcomes.common import ExtendedOutcome
+        from negmas.preferences import LinearUtilityFunction
+
+        issues = [make_issue(5, name="price"), make_issue(3, name="quantity")]
+        ufun = LinearUtilityFunction.random(issues=issues)
+
+        extended = ExtendedOutcome(outcome=None, outcome_space=None)
+
+        result = extended.best_for(ufun)
+        assert result is None
+
+    def test_best_for_with_singleton_outcome_space(self):
+        """Test best_for with a SingletonOutcomeSpace (single outcome in space)."""
+        from negmas.outcomes.common import ExtendedOutcome
+        from negmas.preferences import LinearUtilityFunction
+
+        issues = [make_issue(5, name="price"), make_issue(3, name="quantity")]
+        ufun = LinearUtilityFunction.random(issues=issues)
+
+        single_outcome = (3, 1)
+        singleton_os = SingletonOutcomeSpace(single_outcome, name="single")
+        extended = ExtendedOutcome(outcome=None, outcome_space=singleton_os)
+
+        result = extended.best_for(ufun)
+        assert result == single_outcome
+
+    def test_best_for_with_negative_weights(self):
+        """Test best_for correctly finds best with negative weights."""
+        from negmas.outcomes.common import ExtendedOutcome
+        from negmas.preferences import LinearUtilityFunction
+
+        issues = [make_issue(5, name="price"), make_issue(3, name="quantity")]
+        os = make_os(issues)
+        # Use negative weights so lower values are better
+        ufun = LinearUtilityFunction(weights=[-1.0, -1.0], issues=issues)
+
+        extended = ExtendedOutcome(outcome=None, outcome_space=os)
+
+        result = extended.best_for(ufun)
+        # With negative weights, best outcome should be (0, 0) - min values
+        assert result == (0, 0)
+        assert ufun(result) == ufun.max()
+
+    def test_best_for_with_mixed_weights(self):
+        """Test best_for correctly finds best with mixed positive/negative weights."""
+        from negmas.outcomes.common import ExtendedOutcome
+        from negmas.preferences import LinearUtilityFunction
+
+        issues = [make_issue(5, name="price"), make_issue(3, name="quantity")]
+        os = make_os(issues)
+        # First issue: higher is better, second issue: lower is better
+        ufun = LinearUtilityFunction(weights=[1.0, -1.0], issues=issues)
+
+        extended = ExtendedOutcome(outcome=None, outcome_space=os)
+
+        result = extended.best_for(ufun)
+        # Best should be (4, 0) - max first, min second
+        assert result == (4, 0)
+        assert ufun(result) == ufun.max()
+
+    def test_extract_outcome_with_extended_outcome(self):
+        """Test extract_outcome extracts the outcome from ExtendedOutcome."""
+        from negmas.outcomes.common import ExtendedOutcome, extract_outcome
+
+        outcome = (5, 10)
+        extended = ExtendedOutcome(outcome=outcome, data={"text": "test"})
+
+        assert extract_outcome(extended) == (5, 10)
+        assert extract_outcome(outcome) == (5, 10)
+        assert extract_outcome(None) is None
+
+    def test_extract_text_with_extended_outcome(self):
+        """Test extract_text extracts text from ExtendedOutcome data."""
+        from negmas.outcomes.common import ExtendedOutcome, extract_text
+
+        extended_with_text = ExtendedOutcome(
+            outcome=(5, 10), data={"text": "My proposal"}
+        )
+        extended_without_text = ExtendedOutcome(outcome=(5, 10), data={"other": "data"})
+        extended_no_data = ExtendedOutcome(outcome=(5, 10))
+
+        assert extract_text(extended_with_text) == "My proposal"
+        assert extract_text(extended_without_text) == ""
+        assert extract_text(extended_no_data) is None
+        assert extract_text((5, 10)) is None
+
+    def test_extended_outcome_is_frozen(self):
+        """Test that ExtendedOutcome is immutable (frozen)."""
+        from negmas.outcomes.common import ExtendedOutcome
+
+        extended = ExtendedOutcome(outcome=(5, 10))
+
+        with pytest.raises(AttributeError):
+            extended.outcome = (1, 2)  # type: ignore
+
+    def test_best_for_with_subset_outcome_space(self):
+        """Test best_for with an outcome_space that's a subset of the ufun's space."""
+        from negmas.outcomes.common import ExtendedOutcome
+        from negmas.preferences import LinearUtilityFunction
+
+        # Create ufun with larger outcome space
+        full_issues = [make_issue(10, name="price"), make_issue(5, name="quantity")]
+        ufun = LinearUtilityFunction(weights=[1.0, 1.0], issues=full_issues)
+
+        # Create a smaller subset outcome space
+        subset_issues = [make_issue(3, name="price"), make_issue(2, name="quantity")]
+        subset_os = make_os(subset_issues)
+
+        extended = ExtendedOutcome(outcome=None, outcome_space=subset_os)
+
+        result = extended.best_for(ufun)
+        # Best in subset should be (2, 1) - max values in the subset
+        assert result == (2, 1)
+        # Verify it's the best within the subset
+        for o in subset_os.enumerate():
+            assert ufun(result) >= ufun(o)