feat(emotion-e4): project memory afterglow conditions
这个提交存在于:
父节点
773c064c5c
当前提交
72b6696b79
共有 5 个文件被更改,包括 248 次插入 和 83 次删除
|
|
@ -6678,16 +6678,20 @@ class DailyStateMixin:
|
|||
values = self._base_state_values(profile)
|
||||
weather_text = self._weather_summary_text(weather)
|
||||
energy = 75
|
||||
composed_at = _now_ts()
|
||||
mood_candidates = []
|
||||
health_cause = ""
|
||||
for cond in active:
|
||||
kind = str(cond.get("kind") or "")
|
||||
if kind in values:
|
||||
values[kind] = _single_line(cond.get("label"), 80)
|
||||
energy += _safe_int(cond.get("energy_delta"), 0, -100, 100)
|
||||
energy += self._condition_effective_energy_delta(cond, now=composed_at)
|
||||
mood = _single_line(cond.get("mood"), 20)
|
||||
if mood and mood != "平稳":
|
||||
mood_candidates.append((mood, _safe_int(cond.get("intensity"), 50, 0, 100)))
|
||||
intensity = _safe_int(cond.get("intensity"), 50, 0, 100)
|
||||
if kind == "memory_afterglow":
|
||||
intensity = max(0, round(intensity * self._memory_afterglow_decay(cond, now=composed_at)))
|
||||
mood_candidates.append((mood, intensity))
|
||||
if kind == "health" and not health_cause:
|
||||
health_cause = _single_line(cond.get("cause"), 120)
|
||||
remembered_dream = self._remembered_daily_dream_label()
|
||||
|
|
@ -6734,6 +6738,21 @@ class DailyStateMixin:
|
|||
result["location_source"] = "dialogue_override"
|
||||
return result
|
||||
|
||||
@staticmethod
|
||||
def _memory_afterglow_decay(cond: dict[str, Any], *, now: float) -> float:
|
||||
if str(cond.get("kind") or "") != "memory_afterglow":
|
||||
return 1.0
|
||||
start_ts = _safe_float(cond.get("start_ts"), now)
|
||||
half_life = max(60.0, min(86400.0, _safe_float(cond.get("half_life_seconds"), 1800.0)))
|
||||
age = max(0.0, now - start_ts)
|
||||
return max(0.0, min(1.0, 0.5 ** (age / half_life)))
|
||||
|
||||
def _condition_effective_energy_delta(self, cond: dict[str, Any], *, now: float) -> int:
|
||||
base = _safe_int(cond.get("energy_delta"), 0, -100, 100)
|
||||
if str(cond.get("kind") or "") != "memory_afterglow":
|
||||
return base
|
||||
return int(round(base * self._memory_afterglow_decay(cond, now=now)))
|
||||
|
||||
def _build_state_note(
|
||||
self,
|
||||
sleep: str,
|
||||
|
|
|
|||
2
main.py
2
main.py
|
|
@ -12347,7 +12347,7 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge
|
|||
if not self._simulation_active(fast_user) and _safe_float(fast_user.get("next_proactive_at"), 0) <= 0:
|
||||
self._schedule_next_proactive(fast_user, now=received_ts)
|
||||
try:
|
||||
self._memory_companion_apply_emotional_drift(session_id=event.unified_msg_origin or "")
|
||||
await self._memory_companion_apply_emotional_drift(session_id=event.unified_msg_origin or "")
|
||||
self._memory_companion_attach_private_context(
|
||||
event,
|
||||
user_id=user_id,
|
||||
|
|
|
|||
|
|
@ -2176,100 +2176,125 @@ class MemoryCompanionAdapterMixin:
|
|||
return
|
||||
logger.debug("[PrivateCompanion] MemoryCompanion QQ 空间发布写入失败: %s", _single_line(exc, 120))
|
||||
|
||||
def _memory_companion_apply_emotional_drift(self, *, session_id: str = "") -> None:
|
||||
"""Pull pending emotional drift events from the memory plugin and apply to daily_state.
|
||||
|
||||
This now includes cross-window emotional continuity: if the bot recently
|
||||
touched emotional memories in other sessions, a dampened residue is also
|
||||
applied to the current daily_state, creating a sense of emotional carryover.
|
||||
"""
|
||||
async def _memory_companion_apply_emotional_drift(self, *, session_id: str = "") -> None:
|
||||
"""Durably project pending memory events into Daily State conditions."""
|
||||
if not getattr(self, "enable_memory_companion_emotional_drift", True):
|
||||
return
|
||||
bridge = self._memory_companion_bridge()
|
||||
if bridge is None:
|
||||
return
|
||||
getter = getattr(bridge, "get_emotional_events", None)
|
||||
if not callable(getter):
|
||||
lister = getattr(bridge, "list_emotion_events", None)
|
||||
acker = getattr(bridge, "ack_emotion_events", None)
|
||||
if not callable(lister) or not callable(acker):
|
||||
return
|
||||
consumer_id = "private_companion.daily_state"
|
||||
cross_window = bool(getattr(self, "enable_memory_companion_cross_window_emotion", True))
|
||||
if not cross_window and not session_id:
|
||||
return
|
||||
try:
|
||||
events = getter(session_id=session_id, limit=3)
|
||||
delivery = await lister(
|
||||
consumer_id=consumer_id,
|
||||
session_id="" if cross_window else session_id,
|
||||
exclude_session_id="",
|
||||
cursor="",
|
||||
limit=6,
|
||||
)
|
||||
except Exception as exc:
|
||||
if self._memory_companion_optional_dependency_failed(exc, where="get_emotional_events"):
|
||||
if self._memory_companion_optional_dependency_failed(exc, where="list_emotion_events"):
|
||||
return
|
||||
logger.debug("[PrivateCompanion] 情绪漂移拉取失败: %s", _single_line(exc, 120))
|
||||
logger.debug("[PrivateCompanion] 情绪余波拉取失败: %s", _single_line(exc, 120))
|
||||
return
|
||||
# Cross-window emotional residue: check if there are recent emotional events
|
||||
# from OTHER sessions that should subtly influence the current state
|
||||
cross_window_delta = 0.0
|
||||
cross_window_hints: list[str] = []
|
||||
cross_state_getter = getattr(bridge, "get_recent_emotional_state", None)
|
||||
if callable(cross_state_getter) and getattr(self, "enable_memory_companion_cross_window_emotion", True):
|
||||
try:
|
||||
cross_state = cross_state_getter()
|
||||
if isinstance(cross_state, dict) and cross_state.get("total", 0) > 0:
|
||||
# Apply a dampened cross-window effect (30% strength)
|
||||
scar_count = cross_state.get("scar_count", 0)
|
||||
warm_count = cross_state.get("warm_count", 0)
|
||||
if scar_count > 0:
|
||||
cross_window_delta = -min(2.0, scar_count * 0.8)
|
||||
cross_window_hints.append("低落")
|
||||
if warm_count > 0:
|
||||
cross_window_delta += min(1.5, warm_count * 0.5)
|
||||
cross_window_hints.append("微暖")
|
||||
except Exception as exc:
|
||||
self._memory_companion_optional_dependency_failed(exc, where="get_recent_emotional_state")
|
||||
if not events and not cross_window_hints:
|
||||
events = delivery.get("events", []) if isinstance(delivery, dict) else []
|
||||
if not isinstance(events, list) or not events:
|
||||
return
|
||||
data = getattr(self, "data", None)
|
||||
if not isinstance(data, dict):
|
||||
return
|
||||
state = data.get("daily_state")
|
||||
if not isinstance(state, dict):
|
||||
state = {}
|
||||
data["daily_state"] = state
|
||||
try:
|
||||
current_energy = float(state.get("energy") or 0.0)
|
||||
except Exception:
|
||||
current_energy = 0.0
|
||||
total_delta = 0.0
|
||||
mood_hints: list[str] = []
|
||||
conditions = data.setdefault("state_conditions", [])
|
||||
if not isinstance(conditions, list):
|
||||
conditions = []
|
||||
data["state_conditions"] = conditions
|
||||
now = time.time()
|
||||
applied_refs: list[dict[str, Any]] = []
|
||||
applied_keys: set[tuple[str, int]] = set()
|
||||
for event in events:
|
||||
delta = float(event.get("energy_delta") or 0.0)
|
||||
total_delta += delta
|
||||
hint = _single_line(event.get("mood_hint"), 40)
|
||||
if hint:
|
||||
mood_hints.append(hint)
|
||||
# Add cross-window residue (already dampened)
|
||||
total_delta += cross_window_delta
|
||||
mood_hints.extend(cross_window_hints)
|
||||
# Safety valve: clamp total drift per cycle
|
||||
total_delta = max(-10.0, min(6.0, total_delta))
|
||||
new_energy = max(0.0, min(100.0, current_energy + total_delta))
|
||||
state["energy"] = round(new_energy, 1)
|
||||
# Apply mood drift with safety valve: only shift if hint is significant
|
||||
if mood_hints:
|
||||
current_mood = _single_line(state.get("mood_bias"), 80)
|
||||
dominant_hint = mood_hints[0]
|
||||
if current_mood and dominant_hint not in current_mood:
|
||||
state["mood_bias"] = _single_line(f"{current_mood},偏{dominant_hint}", 80)
|
||||
elif not current_mood:
|
||||
state["mood_bias"] = dominant_hint
|
||||
drift_log = state.get("mood_drift_log")
|
||||
if not isinstance(drift_log, list):
|
||||
drift_log = []
|
||||
state["mood_drift_log"] = drift_log
|
||||
drift_log.append({
|
||||
"ts": self._memory_companion_now_iso(),
|
||||
"events": [{"type": e.get("event_type"), "delta": e.get("energy_delta"), "hint": _single_line(e.get("mood_hint"), 40)} for e in events],
|
||||
"cross_window_delta": round(cross_window_delta, 2),
|
||||
"total_delta": round(total_delta, 2),
|
||||
})
|
||||
if len(drift_log) > 20:
|
||||
drift_log[:] = drift_log[-20:]
|
||||
logger.debug(
|
||||
"[PrivateCompanion] 情绪漂移已应用: energy=%.1f->%.1f delta=%.1f cross_delta=%.1f hints=%s",
|
||||
current_energy, new_energy, total_delta, cross_window_delta, mood_hints,
|
||||
)
|
||||
if not isinstance(event, dict):
|
||||
continue
|
||||
condition = self._memory_companion_afterglow_condition(event, now=now)
|
||||
if not condition:
|
||||
continue
|
||||
event_id = condition["source_event_id"]
|
||||
replaced = False
|
||||
for index, existing in enumerate(conditions):
|
||||
if isinstance(existing, dict) and existing.get("kind") == "memory_afterglow" and existing.get("source_event_id") == event_id:
|
||||
conditions[index] = condition
|
||||
replaced = True
|
||||
break
|
||||
if not replaced:
|
||||
conditions.append(condition)
|
||||
ref_key = (event_id, condition["source_revision"])
|
||||
if ref_key not in applied_keys:
|
||||
applied_keys.add(ref_key)
|
||||
applied_refs.append({"event_id": event_id, "revision": condition["source_revision"]})
|
||||
if not applied_refs:
|
||||
return
|
||||
composer = getattr(self, "_compose_state_from_conditions", None)
|
||||
saver = getattr(self, "_save_data_sync", None)
|
||||
if not callable(composer) or not callable(saver):
|
||||
return
|
||||
data["daily_state"] = composer(data.get("daily_weather", {}))
|
||||
saver()
|
||||
try:
|
||||
await acker(applied_refs, consumer_id=consumer_id)
|
||||
except Exception as exc:
|
||||
self._memory_companion_optional_dependency_failed(exc, where="ack_emotion_events")
|
||||
return
|
||||
logger.debug("[PrivateCompanion] 已应用并确认记忆情绪余波: count=%s", len(applied_refs))
|
||||
|
||||
def _memory_companion_afterglow_condition(self, event: dict[str, Any], *, now: float) -> dict[str, Any] | None:
|
||||
event_id = _single_line(event.get("event_id"), 96)
|
||||
if not event_id:
|
||||
return None
|
||||
try:
|
||||
revision = max(1, min(1000000, int(event.get("revision") or 1)))
|
||||
delta = max(-8.0, min(5.0, float(event.get("energy_delta") or 0.0)))
|
||||
intensity = max(0, min(100, round(float(event.get("intensity") or 0.0))))
|
||||
except (TypeError, ValueError):
|
||||
return None
|
||||
event_type = _single_line(event.get("event_type"), 48)
|
||||
mood_by_type = {
|
||||
"scar_touched": "低落",
|
||||
"warm_memory": "微暖",
|
||||
"vulnerable_resonance": "柔软",
|
||||
}
|
||||
mood = mood_by_type.get(event_type, "平稳")
|
||||
source_session = _single_line(event.get("session_id"), 220)
|
||||
half_life = 1800.0
|
||||
return {
|
||||
"id": f"memory-afterglow-{event_id}",
|
||||
"kind": "memory_afterglow",
|
||||
"title": "记忆余波",
|
||||
"label": "记忆被触动后留下的短暂情绪余波",
|
||||
"mood": mood,
|
||||
"energy_delta": round(delta, 2),
|
||||
"intensity": intensity,
|
||||
"start_ts": now,
|
||||
"end_ts": now + 4 * half_life,
|
||||
"duration_hours": 2,
|
||||
"half_life_seconds": half_life,
|
||||
"cause": "memory_recall_resonance",
|
||||
"phase": "afterglow",
|
||||
"source_event_id": event_id,
|
||||
"source_revision": revision,
|
||||
"source_session_id": source_session,
|
||||
"trace_id": _single_line(event.get("trace_id"), 96),
|
||||
"modulation": {
|
||||
"valence": max(-1.0, min(1.0, _safe_float(event.get("valence"), 0.0))),
|
||||
"arousal": max(0.0, min(1.0, _safe_float(event.get("arousal"), 0.0))),
|
||||
"vulnerability": max(0.0, min(1.0, _safe_float(event.get("vulnerability"), 0.0))),
|
||||
"confidence": max(0.0, min(1.0, _safe_float(event.get("confidence"), 0.0))),
|
||||
},
|
||||
}
|
||||
|
||||
async def _memory_companion_search_open_loops(self, *, session_id: str = "", limit: int = 3) -> list[dict[str, Any]]:
|
||||
"""Search for unresolved open-loop / promise memories for proactive companionship."""
|
||||
|
|
|
|||
|
|
@ -3210,7 +3210,7 @@ class ProactiveMessageMixin:
|
|||
return ""
|
||||
# Pull cross-session emotional drift before generating proactive message
|
||||
try:
|
||||
self._memory_companion_apply_emotional_drift(session_id="")
|
||||
await self._memory_companion_apply_emotional_drift(session_id="")
|
||||
except Exception:
|
||||
pass
|
||||
prompt = await self._build_framework_proactive_prompt(
|
||||
|
|
|
|||
|
|
@ -0,0 +1,121 @@
|
|||
from __future__ import annotations
|
||||
|
||||
import ast
|
||||
import asyncio
|
||||
import importlib.util
|
||||
from pathlib import Path
|
||||
import sys
|
||||
import types
|
||||
import unittest
|
||||
from types import SimpleNamespace
|
||||
from typing import Any
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
|
||||
if "astrbot.api" not in sys.modules:
|
||||
astrbot = types.ModuleType("astrbot")
|
||||
api = types.ModuleType("astrbot.api")
|
||||
api.logger = SimpleNamespace(debug=lambda *args, **kwargs: None, warning=lambda *args, **kwargs: None)
|
||||
sys.modules["astrbot"] = astrbot
|
||||
sys.modules["astrbot.api"] = api
|
||||
|
||||
|
||||
def load_adapter():
|
||||
package_name = "emotion_e4_companion"
|
||||
package = types.ModuleType(package_name)
|
||||
package.__path__ = [str(ROOT)]
|
||||
sys.modules[package_name] = package
|
||||
spec = importlib.util.spec_from_file_location(
|
||||
f"{package_name}.memory_companion_adapter", ROOT / "memory_companion_adapter.py"
|
||||
)
|
||||
assert spec and spec.loader
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
sys.modules[spec.name] = module
|
||||
spec.loader.exec_module(module)
|
||||
return module.MemoryCompanionAdapterMixin
|
||||
|
||||
|
||||
MemoryCompanionAdapterMixin = load_adapter()
|
||||
|
||||
|
||||
class Bridge:
|
||||
def __init__(self) -> None:
|
||||
self.acked: list[dict[str, Any]] = []
|
||||
|
||||
async def list_emotion_events(self, **_kwargs: Any) -> dict[str, Any]:
|
||||
event = {
|
||||
"event_id": "emo-a",
|
||||
"revision": 1,
|
||||
"trace_id": "trace-a",
|
||||
"session_id": "session-a",
|
||||
"event_type": "warm_memory",
|
||||
"energy_delta": 4.0,
|
||||
"intensity": 80,
|
||||
"valence": 0.5,
|
||||
"arousal": 0.3,
|
||||
"vulnerability": 0.2,
|
||||
"confidence": 0.9,
|
||||
}
|
||||
return {"events": [event, dict(event)]}
|
||||
|
||||
async def ack_emotion_events(self, refs: list[dict[str, Any]], **_kwargs: Any) -> dict[str, Any]:
|
||||
self.acked.extend(refs)
|
||||
return {"acked": len(refs)}
|
||||
|
||||
|
||||
class Host(MemoryCompanionAdapterMixin):
|
||||
enable_memory_companion_emotional_drift = True
|
||||
enable_memory_companion_cross_window_emotion = True
|
||||
|
||||
def __init__(self, bridge: Bridge) -> None:
|
||||
self.bridge = bridge
|
||||
self.data = {"state_conditions": [], "daily_weather": {}}
|
||||
self.saved = 0
|
||||
|
||||
def _memory_companion_bridge(self):
|
||||
return self.bridge
|
||||
|
||||
def _compose_state_from_conditions(self, _weather: dict[str, Any]) -> dict[str, Any]:
|
||||
return {"energy": 79, "conditions": list(self.data["state_conditions"])}
|
||||
|
||||
def _save_data_sync(self) -> None:
|
||||
self.saved += 1
|
||||
|
||||
|
||||
class EmotionE4AfterglowConditionTests(unittest.TestCase):
|
||||
def test_afterglow_upserts_by_event_id_and_acks_after_save(self) -> None:
|
||||
bridge = Bridge()
|
||||
host = Host(bridge)
|
||||
asyncio.run(host._memory_companion_apply_emotional_drift(session_id="session-a"))
|
||||
self.assertEqual(1, host.saved)
|
||||
self.assertEqual(1, len(host.data["state_conditions"]))
|
||||
condition = host.data["state_conditions"][0]
|
||||
self.assertEqual("memory_afterglow", condition["kind"])
|
||||
self.assertEqual("emo-a", condition["source_event_id"])
|
||||
self.assertEqual(1800.0, condition["half_life_seconds"])
|
||||
self.assertEqual([{"event_id": "emo-a", "revision": 1}], bridge.acked)
|
||||
|
||||
def test_afterglow_decay_is_monotonic(self) -> None:
|
||||
source = (ROOT / "daily_state.py").read_text(encoding="utf-8")
|
||||
tree = ast.parse(source)
|
||||
owner = next(node for node in tree.body if isinstance(node, ast.ClassDef) and node.name == "DailyStateMixin")
|
||||
methods = {
|
||||
node.name: node
|
||||
for node in owner.body
|
||||
if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
|
||||
and node.name in {"_memory_afterglow_decay", "_condition_effective_energy_delta"}
|
||||
}
|
||||
module = ast.Module(body=list(methods.values()), type_ignores=[])
|
||||
ast.fix_missing_locations(module)
|
||||
namespace = {"Any": Any, "_safe_float": lambda value, default=0.0: float(value or default), "_safe_int": lambda value, default=0, *_args: int(float(value or default))}
|
||||
exec(compile(module, str(ROOT / "daily_state.py"), "exec"), namespace)
|
||||
host = SimpleNamespace()
|
||||
host._memory_afterglow_decay = lambda cond, now: namespace["_memory_afterglow_decay"](cond, now=now)
|
||||
condition = {"kind": "memory_afterglow", "energy_delta": -8, "start_ts": 1000.0, "half_life_seconds": 100.0}
|
||||
values = [namespace["_condition_effective_energy_delta"](host, condition, now=at) for at in (1000.0, 1100.0, 1200.0)]
|
||||
self.assertEqual([-8, -4, -2], values)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
正在加载…
添加表格
在新工单中引用