feat(emotion-e4): add reliable afterglow delivery
这个提交存在于:
父节点
e9872cc4dd
当前提交
d43e704b70
共有 4 个文件被更改,包括 319 次插入 和 7 次删除
|
|
@ -1093,9 +1093,39 @@ class MemoryCompanionBridge:
|
|||
return await self._plugin.store.update_memory_visibility(memory_id, visibility)
|
||||
|
||||
def get_emotional_events(self, *, session_id: str = "", limit: int = 5) -> list[dict[str, Any]]:
|
||||
"""Retrieve pending emotional drift events for the companion plugin."""
|
||||
"""Legacy read-and-remove compatibility path; new consumers use list/ack."""
|
||||
return self._plugin.bridge_get_emotional_events(session_id=session_id, limit=limit)
|
||||
|
||||
async def list_emotion_events(
|
||||
self,
|
||||
*,
|
||||
consumer_id: str,
|
||||
cursor: str = "",
|
||||
session_id: str = "",
|
||||
exclude_session_id: str = "",
|
||||
limit: int = 10,
|
||||
) -> dict[str, Any]:
|
||||
"""List redacted pending afterglow events without consuming them."""
|
||||
return await self._plugin.store.list_emotion_event_deliveries(
|
||||
consumer_id=consumer_id,
|
||||
cursor=cursor,
|
||||
session_id=session_id,
|
||||
exclude_session_id=exclude_session_id,
|
||||
limit=limit,
|
||||
)
|
||||
|
||||
async def ack_emotion_events(
|
||||
self,
|
||||
event_refs: list[dict[str, Any]],
|
||||
*,
|
||||
consumer_id: str,
|
||||
) -> dict[str, Any]:
|
||||
"""Acknowledge only events durably applied by the named consumer."""
|
||||
return await self._plugin.store.ack_emotion_event_deliveries(
|
||||
consumer_id=consumer_id,
|
||||
event_refs=event_refs,
|
||||
)
|
||||
|
||||
async def record_emotion_event(self, event: dict[str, Any]) -> dict[str, Any]:
|
||||
"""Persist one redacted event revision outside normal memory retrieval."""
|
||||
return await self._plugin.store.upsert_emotion_event(event)
|
||||
|
|
@ -1197,7 +1227,13 @@ class MemoryCompanionBridge:
|
|||
projection["touch_count"] = touch_count
|
||||
return projection
|
||||
|
||||
def get_recent_emotional_state(self) -> dict[str, Any]:
|
||||
def get_recent_emotional_state(
|
||||
self,
|
||||
*,
|
||||
exclude_session_id: str = "",
|
||||
window_seconds: float = 1800.0,
|
||||
limit: int = 5,
|
||||
) -> dict[str, Any]:
|
||||
"""Return a summary of recent emotional events across ALL sessions.
|
||||
|
||||
This provides cross-window emotional continuity for the companion plugin:
|
||||
|
|
@ -1207,7 +1243,11 @@ class MemoryCompanionBridge:
|
|||
getter = getattr(self._plugin, "_get_cross_window_emotional_state", None)
|
||||
if not callable(getter):
|
||||
return {"total": 0, "scar_count": 0, "warm_count": 0, "vulnerable_count": 0}
|
||||
return getter()
|
||||
return getter(
|
||||
exclude_session_id=exclude_session_id,
|
||||
window_seconds=window_seconds,
|
||||
limit=limit,
|
||||
)
|
||||
|
||||
def _entity(self, payload: dict[str, Any]) -> EntityRef:
|
||||
return EntityRef(
|
||||
|
|
|
|||
|
|
@ -1824,7 +1824,13 @@ class MemoryCompanionService:
|
|||
return ""
|
||||
return " ".join(hints)
|
||||
|
||||
def _get_cross_window_emotional_state(self) -> dict[str, Any]:
|
||||
def _get_cross_window_emotional_state(
|
||||
self,
|
||||
*,
|
||||
exclude_session_id: str = "",
|
||||
window_seconds: float = 1800.0,
|
||||
limit: int = 5,
|
||||
) -> dict[str, Any]:
|
||||
"""Return a summary of recent emotional events across all sessions for the companion plugin."""
|
||||
if not self.config.bool("private_companion_bridge.cross_window_emotional_continuity_enabled", False):
|
||||
return {
|
||||
|
|
@ -1835,13 +1841,23 @@ class MemoryCompanionService:
|
|||
"vulnerable_count": 0,
|
||||
}
|
||||
now = time.time()
|
||||
recent_window = 1800.0
|
||||
recent_window = max(60.0, min(86400.0, float(window_seconds or 1800.0)))
|
||||
excluded = clean_text(exclude_session_id, 220)
|
||||
all_events: list[dict[str, Any]] = []
|
||||
for session_id, queue in self._emotional_event_queue.items():
|
||||
if excluded and session_id == excluded:
|
||||
continue
|
||||
for event in queue:
|
||||
age = now - event.get("ts", 0)
|
||||
if age < recent_window:
|
||||
all_events.append({**event, "age_seconds": round(age, 0)})
|
||||
all_events.append({
|
||||
"event_id": clean_text(event.get("event_id") or event.get("id"), 96),
|
||||
"session_id": clean_text(event.get("session_id"), 220),
|
||||
"event_type": clean_text(event.get("event_type"), 48),
|
||||
"energy_delta": max(-8.0, min(5.0, float(event.get("energy_delta") or 0.0))),
|
||||
"age_seconds": round(max(0.0, age), 0),
|
||||
"ts": float(event.get("ts") or 0.0),
|
||||
})
|
||||
if not all_events:
|
||||
return {"total": 0, "scar_count": 0, "warm_count": 0, "vulnerable_count": 0}
|
||||
all_events.sort(key=lambda e: e.get("ts", 0), reverse=True)
|
||||
|
|
@ -1850,7 +1866,7 @@ class MemoryCompanionService:
|
|||
"scar_count": sum(1 for e in all_events if e.get("event_type") == "scar_touched"),
|
||||
"warm_count": sum(1 for e in all_events if e.get("event_type") == "warm_memory"),
|
||||
"vulnerable_count": sum(1 for e in all_events if e.get("event_type") == "vulnerable_resonance"),
|
||||
"recent": all_events[:5],
|
||||
"recent": all_events[: max(1, min(20, int(limit or 5)))],
|
||||
}
|
||||
|
||||
async def _retrieval_cache_key(
|
||||
|
|
|
|||
184
core/store.py
184
core/store.py
|
|
@ -521,6 +521,20 @@ class MemoryStore:
|
|||
created_at TEXT NOT NULL DEFAULT '',
|
||||
PRIMARY KEY(event_id, revision)
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS emotion_event_deliveries (
|
||||
event_id TEXT NOT NULL,
|
||||
revision INTEGER NOT NULL DEFAULT 1,
|
||||
consumer_id TEXT NOT NULL,
|
||||
attempts INTEGER NOT NULL DEFAULT 0,
|
||||
first_delivered_at TEXT NOT NULL DEFAULT '',
|
||||
last_delivered_at TEXT NOT NULL DEFAULT '',
|
||||
acked_at TEXT NOT NULL DEFAULT '',
|
||||
PRIMARY KEY(event_id, revision, consumer_id),
|
||||
FOREIGN KEY(event_id, revision)
|
||||
REFERENCES emotion_events(event_id, revision)
|
||||
ON DELETE CASCADE
|
||||
);
|
||||
"""
|
||||
)
|
||||
self._ensure_memory_columns_sync()
|
||||
|
|
@ -582,6 +596,10 @@ class MemoryStore:
|
|||
self._conn.execute(
|
||||
"CREATE INDEX IF NOT EXISTS idx_emotion_events_dedupe ON emotion_events(dedupe_key, event_type)"
|
||||
)
|
||||
self._conn.execute(
|
||||
"CREATE INDEX IF NOT EXISTS idx_emotion_event_deliveries_pending "
|
||||
"ON emotion_event_deliveries(consumer_id, acked_at, last_delivered_at)"
|
||||
)
|
||||
self._conn.commit()
|
||||
|
||||
def _ensure_retrieval_revision_sync(self) -> None:
|
||||
|
|
@ -5649,6 +5667,172 @@ class MemoryStore:
|
|||
).fetchall()
|
||||
return [self._emotion_event_row(row) for row in rows]
|
||||
|
||||
async def list_emotion_event_deliveries(
|
||||
self,
|
||||
*,
|
||||
consumer_id: str,
|
||||
session_id: str = "",
|
||||
exclude_session_id: str = "",
|
||||
cursor: str = "",
|
||||
limit: int = 10,
|
||||
) -> dict[str, Any]:
|
||||
return await self._run_recoverable_database_operation(
|
||||
self._list_emotion_event_deliveries_sync,
|
||||
consumer_id,
|
||||
session_id,
|
||||
exclude_session_id,
|
||||
cursor,
|
||||
limit,
|
||||
)
|
||||
|
||||
def _list_emotion_event_deliveries_sync(
|
||||
self,
|
||||
consumer_id: str,
|
||||
session_id: str,
|
||||
exclude_session_id: str,
|
||||
cursor: str,
|
||||
limit: int,
|
||||
) -> dict[str, Any]:
|
||||
consumer = clean_text(consumer_id, 80)
|
||||
if not consumer:
|
||||
return {"schema_version": "emotion_afterglow_delivery.v1", "events": [], "next_cursor": "", "has_more": False}
|
||||
session = clean_text(session_id, 220)
|
||||
excluded = clean_text(exclude_session_id, 220)
|
||||
bounded_limit = max(1, min(20, int(limit or 10)))
|
||||
clauses = [
|
||||
"e.origin_kind='memory_recall'",
|
||||
"e.status NOT IN ('ignored','expired')",
|
||||
"COALESCE(d.acked_at, '')=''",
|
||||
]
|
||||
params: list[Any] = [consumer]
|
||||
if session:
|
||||
clauses.append("e.session_id=?")
|
||||
params.append(session)
|
||||
if excluded:
|
||||
clauses.append("e.session_id!=?")
|
||||
params.append(excluded)
|
||||
with self._lock:
|
||||
rows = self._conn.execute(
|
||||
f"""
|
||||
SELECT e.*
|
||||
FROM emotion_events e
|
||||
JOIN (
|
||||
SELECT event_id, MAX(revision) AS revision
|
||||
FROM emotion_events
|
||||
GROUP BY event_id
|
||||
) latest ON latest.event_id=e.event_id AND latest.revision=e.revision
|
||||
LEFT JOIN emotion_event_deliveries d
|
||||
ON d.event_id=e.event_id AND d.revision=e.revision AND d.consumer_id=?
|
||||
WHERE {' AND '.join(clauses)}
|
||||
ORDER BY e.occurred_at DESC, e.event_id DESC, e.revision DESC
|
||||
LIMIT 201
|
||||
""",
|
||||
params,
|
||||
).fetchall()
|
||||
events = [self._emotion_event_row(row) for row in rows]
|
||||
cursor_value = clean_text(cursor, 400)
|
||||
if cursor_value:
|
||||
positions = [self._emotion_delivery_cursor(item) for item in events]
|
||||
try:
|
||||
events = events[positions.index(cursor_value) + 1 :]
|
||||
except ValueError:
|
||||
events = []
|
||||
page = events[:bounded_limit]
|
||||
has_more = len(events) > bounded_limit
|
||||
delivered_at = utc_now()
|
||||
for event in page:
|
||||
self._conn.execute(
|
||||
"""
|
||||
INSERT INTO emotion_event_deliveries(
|
||||
event_id, revision, consumer_id, attempts,
|
||||
first_delivered_at, last_delivered_at, acked_at
|
||||
) VALUES(?,?,?,1,?,?,'')
|
||||
ON CONFLICT(event_id, revision, consumer_id) DO UPDATE SET
|
||||
attempts=emotion_event_deliveries.attempts+1,
|
||||
last_delivered_at=excluded.last_delivered_at
|
||||
""",
|
||||
(event["event_id"], event["revision"], consumer, delivered_at, delivered_at),
|
||||
)
|
||||
self._conn.commit()
|
||||
projection = [self._emotion_delivery_projection(event) for event in page]
|
||||
return {
|
||||
"schema_version": "emotion_afterglow_delivery.v1",
|
||||
"events": projection,
|
||||
"next_cursor": self._emotion_delivery_cursor(page[-1]) if page and has_more else "",
|
||||
"has_more": has_more,
|
||||
}
|
||||
|
||||
async def ack_emotion_event_deliveries(
|
||||
self,
|
||||
*,
|
||||
consumer_id: str,
|
||||
event_refs: list[dict[str, Any]],
|
||||
) -> dict[str, Any]:
|
||||
return await self._run_recoverable_database_operation(
|
||||
self._ack_emotion_event_deliveries_sync, consumer_id, event_refs
|
||||
)
|
||||
|
||||
def _ack_emotion_event_deliveries_sync(
|
||||
self,
|
||||
consumer_id: str,
|
||||
event_refs: list[dict[str, Any]],
|
||||
) -> dict[str, Any]:
|
||||
consumer = clean_text(consumer_id, 80)
|
||||
if not consumer or not isinstance(event_refs, list):
|
||||
return {"acked": 0, "consumer_id": consumer}
|
||||
unique_refs: set[tuple[str, int]] = set()
|
||||
for item in event_refs[:100]:
|
||||
if not isinstance(item, dict):
|
||||
continue
|
||||
event_id = clean_text(item.get("event_id"), 96)
|
||||
try:
|
||||
revision = max(1, min(1000000, int(item.get("revision") or 1)))
|
||||
except (TypeError, ValueError):
|
||||
continue
|
||||
if event_id:
|
||||
unique_refs.add((event_id, revision))
|
||||
acked_at = utc_now()
|
||||
acked = 0
|
||||
with self._lock:
|
||||
for event_id, revision in unique_refs:
|
||||
cursor = self._conn.execute(
|
||||
"""
|
||||
UPDATE emotion_event_deliveries
|
||||
SET acked_at=?
|
||||
WHERE event_id=? AND revision=? AND consumer_id=? AND acked_at=''
|
||||
""",
|
||||
(acked_at, event_id, revision, consumer),
|
||||
)
|
||||
acked += max(0, int(cursor.rowcount or 0))
|
||||
self._conn.commit()
|
||||
return {"acked": acked, "consumer_id": consumer, "acked_at": acked_at}
|
||||
|
||||
@staticmethod
|
||||
def _emotion_delivery_cursor(event: dict[str, Any]) -> str:
|
||||
return "|".join((
|
||||
clean_text(event.get("occurred_at"), 48),
|
||||
clean_text(event.get("event_id"), 96),
|
||||
str(max(1, int(event.get("revision") or 1))),
|
||||
))
|
||||
|
||||
@staticmethod
|
||||
def _emotion_delivery_projection(event: dict[str, Any]) -> dict[str, Any]:
|
||||
return {
|
||||
"event_id": clean_text(event.get("event_id"), 96),
|
||||
"revision": max(1, int(event.get("revision") or 1)),
|
||||
"trace_id": clean_text(event.get("trace_id"), 96),
|
||||
"session_id": clean_text(event.get("session_id"), 220),
|
||||
"event_type": clean_text(event.get("event_type"), 48),
|
||||
"intensity": float(event.get("intensity") or 0.0),
|
||||
"confidence": float(event.get("confidence") or 0.0),
|
||||
"energy_delta": float(event.get("applied_energy_delta") or 0.0),
|
||||
"valence": float(event.get("valence_hint") or 0.0),
|
||||
"arousal": float(event.get("arousal_hint") or 0.0),
|
||||
"vulnerability": float(event.get("vulnerability_hint") or 0.0),
|
||||
"occurred_at": clean_text(event.get("occurred_at"), 48),
|
||||
"expires_at": clean_text(event.get("expires_at"), 48),
|
||||
}
|
||||
|
||||
@staticmethod
|
||||
def _emotion_event_row(row: sqlite3.Row) -> dict[str, Any]:
|
||||
result = dict(row)
|
||||
|
|
|
|||
|
|
@ -0,0 +1,72 @@
|
|||
from __future__ import annotations
|
||||
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT))
|
||||
|
||||
from core.emotion_event_contract import normalize_emotion_event # noqa: E402
|
||||
from core.store import MemoryStore # noqa: E402
|
||||
|
||||
|
||||
class EmotionE4AfterglowDeliveryTests(unittest.IsolatedAsyncioTestCase):
|
||||
def make_store(self) -> MemoryStore:
|
||||
temp_dir = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(temp_dir.cleanup)
|
||||
store = MemoryStore(Path(temp_dir.name) / "memory.db")
|
||||
store.initialize()
|
||||
self.addCleanup(store.close)
|
||||
return store
|
||||
|
||||
async def add_event(self, store: MemoryStore, *, session_id: str, suffix: str) -> dict:
|
||||
event = normalize_emotion_event({
|
||||
"event_id": f"emo-{suffix}",
|
||||
"trace_id": f"trace-{suffix}",
|
||||
"origin_kind": "memory_recall",
|
||||
"session_id": session_id,
|
||||
"event_type": "warm_memory",
|
||||
"applied_energy_delta": 3.5,
|
||||
"valence_hint": 0.4,
|
||||
"dedupe_key": suffix,
|
||||
}, producer_plugin="memory_companion")
|
||||
return await store.upsert_emotion_event(event)
|
||||
|
||||
async def test_list_retries_until_ack_and_returns_redacted_projection(self) -> None:
|
||||
store = self.make_store()
|
||||
event = await self.add_event(store, session_id="session-a", suffix="a")
|
||||
first = await store.list_emotion_event_deliveries(
|
||||
consumer_id="companion", session_id="session-a", limit=5
|
||||
)
|
||||
retry = await store.list_emotion_event_deliveries(
|
||||
consumer_id="companion", session_id="session-a", limit=5
|
||||
)
|
||||
self.assertEqual([event["event_id"]], [item["event_id"] for item in first["events"]])
|
||||
self.assertEqual(first["events"], retry["events"])
|
||||
self.assertNotIn("memory_id", repr(first))
|
||||
self.assertNotIn("actor_ref", repr(first))
|
||||
ack = await store.ack_emotion_event_deliveries(
|
||||
consumer_id="companion",
|
||||
event_refs=[{"event_id": event["event_id"], "revision": 1}],
|
||||
)
|
||||
self.assertEqual(1, ack["acked"])
|
||||
empty = await store.list_emotion_event_deliveries(
|
||||
consumer_id="companion", session_id="session-a", limit=5
|
||||
)
|
||||
self.assertEqual([], empty["events"])
|
||||
|
||||
async def test_session_and_exclusion_filters_prevent_double_delivery(self) -> None:
|
||||
store = self.make_store()
|
||||
await self.add_event(store, session_id="session-a", suffix="a")
|
||||
event_b = await self.add_event(store, session_id="session-b", suffix="b")
|
||||
page = await store.list_emotion_event_deliveries(
|
||||
consumer_id="companion", exclude_session_id="session-a", limit=5
|
||||
)
|
||||
self.assertEqual([event_b["event_id"]], [item["event_id"] for item in page["events"]])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
正在加载…
添加表格
在新工单中引用