diff --git a/core/bridge.py b/core/bridge.py index d1193e1..85e481c 100644 --- a/core/bridge.py +++ b/core/bridge.py @@ -34,7 +34,13 @@ _COMPANION_INTERACTION_BANDS = { "close", "affectionate", } -_COMPANION_EXPRESSION_CONTRACT = "companion_interaction_expression.v1" +_COMPANION_EXPRESSION_CONTRACTS = {"companion_interaction_expression.v1", "companion_interaction_expression.v2"} +_COMPANION_EXPRESSION_PACING = {"slow", "steady", "bright"} +_COMPANION_EXPRESSION_DIRECTNESS = {"indirect", "natural", "direct"} +_COMPANION_EXPRESSION_VALIDATION = {"none", "acknowledge", "support_first"} +_COMPANION_EXPRESSION_DISCLOSURE = {"none", "light", "allowed"} +_COMPANION_EXPRESSION_HUMOR = {"off", "light", "playful"} +_COMPANION_EXPRESSION_TOPIC = {"reply_only", "followup", "shared_topic"} _COMPANION_EXPRESSION_BEHAVIORS = { "acknowledge", "brief_reply", @@ -81,7 +87,7 @@ def sanitize_companion_expression_decision(value: Any) -> dict[str, Any]: """Accept only the bounded, request-scoped Companion expression contract.""" fallback = {"status": "invalid", "read_only": True, "decision": {}} - if type(value) is not dict or value.get("contract") != _COMPANION_EXPRESSION_CONTRACT: + if type(value) is not dict or value.get("contract") not in _COMPANION_EXPRESSION_CONTRACTS: return fallback expression_band = value.get("expression_band") if type(expression_band) is not str or expression_band not in _COMPANION_INTERACTION_BANDS: @@ -106,16 +112,33 @@ def sanitize_companion_expression_decision(value: Any) -> dict[str, Any]: return fallback if type(value.get("followup")) is not bool: return fallback + contract = value.get("contract") + dimensions: dict[str, str] = {} + if contract == "companion_interaction_expression.v2": + dimension_specs = { + "pacing": _COMPANION_EXPRESSION_PACING, + "directness": _COMPANION_EXPRESSION_DIRECTNESS, + "validation_style": _COMPANION_EXPRESSION_VALIDATION, + "self_disclosure": _COMPANION_EXPRESSION_DISCLOSURE, + "humor_mode": _COMPANION_EXPRESSION_HUMOR, + "topic_initiative": _COMPANION_EXPRESSION_TOPIC, + } + for key, allowed in dimension_specs.items(): + item = value.get(key) + if type(item) is not str or item not in allowed: + return fallback + dimensions[key] = item return { "status": "accepted", "read_only": True, "decision": { - "contract": _COMPANION_EXPRESSION_CONTRACT, + "contract": contract, "expression_band": expression_band, "allowed_behaviors": list(allowed_behaviors), "safety_mode": safety_mode, "blocker": blocker, "reason_codes": list(reason_codes), + **dimensions, }, } diff --git a/core/models.py b/core/models.py index fe8eb62..cbc3fb0 100644 --- a/core/models.py +++ b/core/models.py @@ -95,6 +95,12 @@ class SessionContext: companion_expression_safety_mode: str = "" companion_expression_blocker: str = "" companion_expression_reason_codes: tuple[str, ...] = () + companion_expression_pacing: str = "" + companion_expression_directness: str = "" + companion_expression_validation_style: str = "" + companion_expression_self_disclosure: str = "" + companion_expression_humor_mode: str = "" + companion_expression_topic_initiative: str = "" @property def current_target_id(self) -> str: diff --git a/core/service.py b/core/service.py index 42031f5..39633d0 100644 --- a/core/service.py +++ b/core/service.py @@ -786,6 +786,12 @@ class MemoryCompanionService: ctx.companion_expression_safety_mode = clean_text(decision.get("safety_mode"), 60) ctx.companion_expression_blocker = clean_text(decision.get("blocker"), 60) ctx.companion_expression_reason_codes = tuple(decision.get("reason_codes") or ()) + ctx.companion_expression_pacing = clean_text(decision.get("pacing"), 24) + ctx.companion_expression_directness = clean_text(decision.get("directness"), 24) + ctx.companion_expression_validation_style = clean_text(decision.get("validation_style"), 24) + ctx.companion_expression_self_disclosure = clean_text(decision.get("self_disclosure"), 24) + ctx.companion_expression_humor_mode = clean_text(decision.get("humor_mode"), 24) + ctx.companion_expression_topic_initiative = clean_text(decision.get("topic_initiative"), 24) def _sanitize_visible_timeline_text(self, text: Any) -> str: cleaned = clean_text(text, 1200) diff --git a/tests/test_emotion_e8_expression_authority.py b/tests/test_emotion_e8_expression_authority.py new file mode 100644 index 0000000..865ef0e --- /dev/null +++ b/tests/test_emotion_e8_expression_authority.py @@ -0,0 +1,54 @@ +from __future__ import annotations + +from types import SimpleNamespace +import unittest + +from core.bridge import sanitize_companion_expression_decision +from core.models import SessionContext +from core.service import MemoryCompanionService + + +def v2_decision(**updates): + value = { + "contract": "companion_interaction_expression.v2", + "expression_band": "warm", + "followup": True, + "allowed_behaviors": ["reply", "support", "followup"], + "safety_mode": "normal", + "blocker": None, + "reason_codes": ["interaction_band_applied"], + "pacing": "steady", + "directness": "natural", + "validation_style": "support_first", + "self_disclosure": "light", + "humor_mode": "light", + "topic_initiative": "followup", + } + value.update(updates) + return value + + +class EmotionE8ExpressionAuthorityTests(unittest.TestCase): + def test_v2_dimensions_are_validated_and_consumed_read_only(self) -> None: + accepted = sanitize_companion_expression_decision(v2_decision()) + self.assertEqual("accepted", accepted["status"]) + self.assertEqual("support_first", accepted["decision"]["validation_style"]) + ctx = SessionContext(scope="private") + req = SimpleNamespace(_private_companion_expression_decision=v2_decision()) + MemoryCompanionService._apply_companion_expression_decision(ctx, req=req) + self.assertEqual("companion_interaction_expression.v2", ctx.companion_expression_contract) + self.assertEqual("light", ctx.companion_expression_humor_mode) + self.assertEqual("followup", ctx.companion_expression_topic_initiative) + + def test_invalid_dimension_fails_closed_and_v1_remains_compatible(self) -> None: + self.assertEqual("invalid", sanitize_companion_expression_decision(v2_decision(humor_mode="override_safety"))["status"]) + legacy = v2_decision(contract="companion_interaction_expression.v1") + for key in ("pacing", "directness", "validation_style", "self_disclosure", "humor_mode", "topic_initiative"): + legacy.pop(key) + accepted = sanitize_companion_expression_decision(legacy) + self.assertEqual("accepted", accepted["status"]) + self.assertNotIn("humor_mode", accepted["decision"]) + + +if __name__ == "__main__": + unittest.main()