From 02d5825844e4dfb48107d315b2d7b621aef3f38c Mon Sep 17 00:00:00 2001 From: agent Date: Wed, 5 Aug 2026 00:52:22 +0800 Subject: [PATCH] feat(emotion-e9): expose scoped trace diagnostics --- core/bridge.py | 38 +++++++ core/store.py | 161 +++++++++++++++++++++++++++ page_api.py | 35 ++++++ pages/记忆面板/app.js | 35 ++++++ tests/test_emotion_e9_trace_query.py | 79 +++++++++++++ 5 files changed, 348 insertions(+) create mode 100644 tests/test_emotion_e9_trace_query.py diff --git a/core/bridge.py b/core/bridge.py index 85e481c..c8dd263 100644 --- a/core/bridge.py +++ b/core/bridge.py @@ -1177,6 +1177,44 @@ class MemoryCompanionBridge: async def get_emotion_trace(self, trace_id: str, *, limit: int = 100) -> list[dict[str, Any]]: return await self._plugin.store.get_emotion_trace(trace_id, limit=limit) + async def get_emotion_trace_diagnostic( + self, + trace_id: str, + requester_context: dict[str, Any], + *, + limit: int = 100, + ) -> dict[str, Any]: + context = requester_context if type(requester_context) is dict else {} + if context.get("is_admin") is not True: + return {"state": "forbidden", "read_only": True, "items": [], "error_code": "admin_required"} + items = await self._plugin.store.get_emotion_trace_diagnostic( + trace_id, + bot_id=clean_text(context.get("bot_id"), 160), + scope=clean_text(context.get("scope"), 24), + session_id=clean_text(context.get("session_id"), 220), + limit=max(1, min(100, int(limit or 100))), + ) + return {"state": "ready", "read_only": True, "items": items} + + async def get_emotion_trace_summary( + self, + requester_context: dict[str, Any], + *, + cursor: str = "", + limit: int = 20, + ) -> dict[str, Any]: + context = requester_context if type(requester_context) is dict else {} + if context.get("is_admin") is not True: + return {"state": "forbidden", "read_only": True, "items": [], "next_cursor": "", "error_code": "admin_required"} + result = await self._plugin.store.get_emotion_trace_summary( + bot_id=clean_text(context.get("bot_id"), 160), + scope=clean_text(context.get("scope"), 24), + session_id=clean_text(context.get("session_id"), 220), + cursor=clean_text(cursor, 20), + limit=max(1, min(100, int(limit or 20))), + ) + return {"state": "ready", "read_only": True, **result} + async def search_open_loops(self, *, session_id: str = "", limit: int = 3) -> list[dict[str, Any]]: """Search for unresolved open-loop / promise memories for proactive companionship.""" return await self._plugin.bridge_search_open_loops(session_id=session_id, limit=limit) diff --git a/core/store.py b/core/store.py index 842f1b4..b2fb60a 100644 --- a/core/store.py +++ b/core/store.py @@ -1,6 +1,7 @@ from __future__ import annotations import asyncio +import hashlib from contextlib import closing, contextmanager from copy import deepcopy import re @@ -5638,6 +5639,166 @@ class MemoryStore: ).fetchall() return [self._emotion_event_row(row) for row in rows] + async def get_emotion_trace_diagnostic( + self, + trace_id: str, + *, + bot_id: str = "", + scope: str = "", + session_id: str = "", + limit: int = 100, + ) -> list[dict[str, Any]]: + return await self._run_recoverable_database_operation( + self._get_emotion_trace_diagnostic_sync, trace_id, bot_id, scope, session_id, limit + ) + + def _get_emotion_trace_diagnostic_sync( + self, + trace_id: str, + bot_id: str, + scope: str, + session_id: str, + limit: int, + ) -> list[dict[str, Any]]: + trace = clean_text(trace_id, 96) + if not trace: + return [] + clauses = ["e.trace_id=?"] + params: list[Any] = [trace] + for column, value, size in (("bot_id", bot_id, 160), ("scope", scope, 24), ("session_id", session_id, 220)): + cleaned = clean_text(value, size) + if cleaned: + clauses.append(f"e.{column}=?") + params.append(cleaned) + params.append(max(1, min(100, int(limit or 100)))) + with self._lock: + rows = self._conn.execute( + f"SELECT e.* FROM emotion_events e WHERE {' AND '.join(clauses)} ORDER BY e.revision ASC LIMIT ?", + params, + ).fetchall() + result: list[dict[str, Any]] = [] + for row in rows: + event = self._emotion_event_row(row) + deliveries = self._conn.execute( + """ + SELECT consumer_id, attempts, first_delivered_at, last_delivered_at, acked_at + FROM emotion_event_deliveries + WHERE event_id=? AND revision=? + ORDER BY consumer_id ASC LIMIT 20 + """, + (event["event_id"], event["revision"]), + ).fetchall() + result.append(self._emotion_diagnostic_projection(event, deliveries)) + return result + + async def get_emotion_trace_summary( + self, + *, + bot_id: str = "", + scope: str = "", + session_id: str = "", + cursor: str = "", + limit: int = 20, + ) -> dict[str, Any]: + return await self._run_recoverable_database_operation( + self._get_emotion_trace_summary_sync, bot_id, scope, session_id, cursor, limit + ) + + def _get_emotion_trace_summary_sync( + self, + bot_id: str, + scope: str, + session_id: str, + cursor: str, + limit: int, + ) -> dict[str, Any]: + clauses = ["1=1"] + params: list[Any] = [] + for column, value, size in (("bot_id", bot_id, 160), ("scope", scope, 24), ("session_id", session_id, 220)): + cleaned = clean_text(value, size) + if cleaned: + clauses.append(f"e.{column}=?") + params.append(cleaned) + try: + offset = max(0, min(100000, int(cursor or 0))) + except (TypeError, ValueError): + offset = 0 + bounded = max(1, min(100, int(limit or 20))) + params.extend((bounded + 1, offset)) + with self._lock: + rows = self._conn.execute( + f""" + SELECT e.* FROM emotion_events e + JOIN (SELECT event_id, MAX(revision) revision FROM emotion_events GROUP BY event_id) latest + ON latest.event_id=e.event_id AND latest.revision=e.revision + WHERE {' AND '.join(clauses)} + ORDER BY e.occurred_at DESC, e.event_id DESC + LIMIT ? OFFSET ? + """, + params, + ).fetchall() + page = [self._emotion_event_row(row) for row in rows[:bounded]] + return { + "items": [{ + "trace_id": clean_text(item.get("trace_id"), 96), + "event_id": clean_text(item.get("event_id"), 96), + "revision": int(item.get("revision") or 1), + "event_type": clean_text(item.get("event_type"), 48), + "status": clean_text(item.get("status"), 24), + "occurred_at": clean_text(item.get("occurred_at"), 48), + "session_hash": self._diagnostic_hash(item.get("session_id")), + } for item in page], + "next_cursor": str(offset + bounded) if len(rows) > bounded else "", + "has_more": len(rows) > bounded, + } + + @classmethod + def _emotion_diagnostic_projection(cls, event: dict[str, Any], deliveries: list[sqlite3.Row]) -> dict[str, Any]: + return { + "schema_version": "emotion_trace_diagnostic.v1", + "event_id": clean_text(event.get("event_id"), 96), + "trace_id": clean_text(event.get("trace_id"), 96), + "revision": int(event.get("revision") or 1), + "producer_plugin": clean_text(event.get("producer_plugin"), 80), + "origin_kind": clean_text(event.get("origin_kind"), 40), + "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), + "status": clean_text(event.get("status"), 24), + "source_rule": clean_text(event.get("source_rule"), 80), + "occurred_at": clean_text(event.get("occurred_at"), 48), + "applied_interaction": clean_text(event.get("applied_interaction"), 32), + "applied_energy_delta": float(event.get("applied_energy_delta") or 0.0), + "correction_of": clean_text(event.get("correction_of"), 96), + "actor": cls._diagnostic_ref(event.get("actor_ref")), + "target": cls._diagnostic_ref(event.get("target_ref")), + "quoted_target": cls._diagnostic_ref(event.get("quoted_target_ref")), + "scope": clean_text(event.get("scope"), 24), + "session_hash": cls._diagnostic_hash(event.get("session_id")), + "deliveries": [{ + "consumer_id": clean_text(row["consumer_id"], 80), + "attempts": max(0, int(row["attempts"] or 0)), + "first_delivered_at": clean_text(row["first_delivered_at"], 48), + "last_delivered_at": clean_text(row["last_delivered_at"], 48), + "acked": bool(row["acked_at"]), + "acked_at": clean_text(row["acked_at"], 48), + } for row in deliveries], + } + + @classmethod + def _diagnostic_ref(cls, value: Any) -> dict[str, str]: + source = value if isinstance(value, dict) else {} + return { + "kind": clean_text(source.get("kind"), 24), + "role": clean_text(source.get("role"), 40), + "id_hash": cls._diagnostic_hash(source.get("id")), + } + + @staticmethod + def _diagnostic_hash(value: Any) -> str: + cleaned = clean_text(value, 220) + return hashlib.sha256(cleaned.encode("utf-8", errors="ignore")).hexdigest()[:12] if cleaned else "" + async def list_emotion_events( self, *, diff --git a/page_api.py b/page_api.py index d1da978..a072ffa 100644 --- a/page_api.py +++ b/page_api.py @@ -79,6 +79,8 @@ class PluginPageApi: ("/config/module/update", self.config_module_update, ["POST"], "MemoryCompanion Page config module update"), ("/retrieval/config/update", self.retrieval_config_update, ["POST"], "MemoryCompanion Page retrieval config update"), ("/operations/diagnostics", self.operations_diagnostics, ["GET"], "MemoryCompanion operations diagnostics"), + ("/emotion/trace", self.emotion_trace, ["GET"], "MemoryCompanion redacted emotion trace"), + ("/emotion/traces", self.emotion_traces, ["GET"], "MemoryCompanion redacted emotion trace list"), ("/coordination/status", self.coordination_status, ["GET"], "MemoryCompanion safe coordination status"), ("/operations/preset", self.operations_preset, ["GET", "POST"], "MemoryCompanion operations preset"), ("/data/export", self.data_export, ["POST"], "MemoryCompanion portable data export"), @@ -195,6 +197,39 @@ class PluginPageApi: except Exception as exc: return self._err(f"运维诊断失败: {exc}", 500) + async def emotion_trace(self): + trace_id = clean_text(request.args.get("trace_id", ""), 96) + if not trace_id: + return self._err("缺少 trace_id", 400) + context = { + "is_admin": True, + "bot_id": clean_text(request.args.get("bot_id", ""), 160), + "scope": clean_text(request.args.get("scope", ""), 24), + "session_id": clean_text(request.args.get("session_id", ""), 220), + } + bridge = getattr(self.plugin, "memory_companion", None) + getter = getattr(bridge, "get_emotion_trace_diagnostic", None) + if not callable(getter): + return self._ok({"result": {"state": "degraded", "read_only": True, "items": [], "error_code": "bridge_method_unavailable"}}) + return self._ok({"result": await getter(trace_id, context, limit=100)}) + + async def emotion_traces(self): + context = { + "is_admin": True, + "bot_id": clean_text(request.args.get("bot_id", ""), 160), + "scope": clean_text(request.args.get("scope", ""), 24), + "session_id": clean_text(request.args.get("session_id", ""), 220), + } + bridge = getattr(self.plugin, "memory_companion", None) + getter = getattr(bridge, "get_emotion_trace_summary", None) + if not callable(getter): + return self._ok({"result": {"state": "degraded", "read_only": True, "items": [], "error_code": "bridge_method_unavailable"}}) + return self._ok({"result": await getter( + context, + cursor=clean_text(request.args.get("cursor", ""), 20), + limit=max(1, min(100, self._int(request.args.get("limit", "20"), 20))), + )}) + async def coordination_status(self): """Expose a fixed, read-only coordination projection.""" try: diff --git a/pages/记忆面板/app.js b/pages/记忆面板/app.js index d8cef87..44f8313 100644 --- a/pages/记忆面板/app.js +++ b/pages/记忆面板/app.js @@ -6231,11 +6231,32 @@ async function loadPersonaState() { let data; try { data = await apiGet("/persona-state"); + try { + const traces = await apiGet("/emotion/traces?scope=private&limit=20"); + data.emotion_trace_diagnostics = traces?.result || traces || {}; + } catch (_) { + data.emotion_trace_diagnostics = { state: "degraded", items: [], error_code: "trace_summary_unavailable" }; + } } catch (err) { panel.innerHTML = `
读取失败:${escapeHtml(err?.message || "未知错误")}
`; return; } panel.innerHTML = renderPersonaState(data || {}); + panel.querySelectorAll("[data-memory-emotion-trace]").forEach((button) => { + button.addEventListener("click", async () => { + const traceId = String(button.dataset.memoryEmotionTrace || ""); + const target = panel.querySelector("[data-memory-emotion-trace-detail]"); + if (!traceId || !target) return; + target.textContent = "正在读取脱敏链路..."; + try { + const response = await apiGet(`/emotion/trace?trace_id=${encodeURIComponent(traceId)}&scope=private`); + const result = response?.result || response || {}; + target.textContent = JSON.stringify(result, null, 2); + } catch (error) { + target.textContent = `degraded: ${error?.message || "trace unavailable"}`; + } + }); + }); } function renderPersonaState(d) { @@ -6246,6 +6267,8 @@ function renderPersonaState(d) { const timeOfDay = d.time_of_day || ""; const legacyLabels = d.legacy_context_labels || {}; const timeLabels = d.time_of_day_labels || {}; + const traceDiagnostics = d.emotion_trace_diagnostics || {}; + const traceItems = Array.isArray(traceDiagnostics.items) ? traceDiagnostics.items.slice(0, 20) : []; const timeLabel = timeLabels[timeOfDay] || timeOfDay || "未知"; const crossTotal = crossState.total || 0; @@ -6275,6 +6298,18 @@ function renderPersonaState(d) { `; + html += ` +
+
情绪链路诊断${escapeHtml(traceDiagnostics.state || "degraded")}
+
+
+ ${traceItems.map((item) => ``).join("") || '

暂无可展示的脱敏 trace。

'} +
+
选择一条 trace 查看事件 revision 与投递确认状态。
+
+
+ `; + html += `
diff --git a/tests/test_emotion_e9_trace_query.py b/tests/test_emotion_e9_trace_query.py new file mode 100644 index 0000000..86c4063 --- /dev/null +++ b/tests/test_emotion_e9_trace_query.py @@ -0,0 +1,79 @@ +from __future__ import annotations + +import tempfile +from pathlib import Path +import unittest + +from core.bridge import MemoryCompanionBridge +from core.emotion_event_contract import normalize_emotion_event +from core.store import MemoryStore + + +class EmotionE9TraceQueryTests(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, *, event_id: str, trace_id: str, bot_id: str, session_id: str) -> None: + await store.upsert_emotion_event(normalize_emotion_event({ + "event_id": event_id, + "trace_id": trace_id, + "origin_kind": "memory_recall", + "bot_id": bot_id, + "scope": "private", + "session_id": session_id, + "event_type": "warm_memory", + "actor_ref": {"kind": "user", "id": "raw-user-id", "role": "speaker"}, + "target_ref": {"kind": "bot", "id": bot_id, "role": "bot_self"}, + "dedupe_key": event_id, + "raw_text": "PRIVATE CHAT /tmp/secret token=abc", + }, producer_plugin="memory_companion")) + + async def test_admin_scope_filter_redaction_and_delivery_status(self) -> None: + store = self.make_store() + await self.add_event(store, event_id="e1", trace_id="trace-shared", bot_id="b1", session_id="s1") + await self.add_event(store, event_id="e2", trace_id="trace-shared", bot_id="b2", session_id="s2") + await store.list_emotion_event_deliveries(consumer_id="companion", session_id="s1", limit=5) + bridge = MemoryCompanionBridge(type("Plugin", (), {"store": store})()) + + denied = await bridge.get_emotion_trace_diagnostic("trace-shared", {"is_admin": False}) + self.assertEqual("forbidden", denied["state"]) + result = await bridge.get_emotion_trace_diagnostic( + "trace-shared", + {"is_admin": True, "bot_id": "b1", "scope": "private", "session_id": "s1"}, + ) + self.assertEqual(1, len(result["items"])) + item = result["items"][0] + self.assertEqual("e1", item["event_id"]) + self.assertEqual(12, len(item["actor"]["id_hash"])) + self.assertEqual(1, item["deliveries"][0]["attempts"]) + rendered = repr(result) + for secret in ("PRIVATE CHAT", "/tmp/secret", "token=abc", "raw-user-id"): + self.assertNotIn(secret, rendered) + + async def test_summary_is_hard_limited_and_paginated_over_1000_events(self) -> None: + store = self.make_store() + for index in range(1005): + await self.add_event(store, event_id=f"e{index}", trace_id=f"t{index}", bot_id="b1", session_id="s1") + bridge = MemoryCompanionBridge(type("Plugin", (), {"store": store})()) + first = await bridge.get_emotion_trace_summary( + {"is_admin": True, "bot_id": "b1", "scope": "private", "session_id": "s1"}, + limit=1000, + ) + self.assertEqual(100, len(first["items"])) + self.assertTrue(first["has_more"]) + second = await bridge.get_emotion_trace_summary( + {"is_admin": True, "bot_id": "b1", "scope": "private", "session_id": "s1"}, + cursor=first["next_cursor"], + limit=100, + ) + self.assertEqual(100, len(second["items"])) + self.assertNotEqual(first["items"][0]["event_id"], second["items"][0]["event_id"]) + + +if __name__ == "__main__": + unittest.main()