feat(emotion-e9): expose scoped trace diagnostics

这个提交存在于:
agent 2026-08-05 00:52:22 +08:00
父节点 4be2c1a754
当前提交 02d5825844
共有 5 个文件被更改,包括 348 次插入 和 0 次删除

查看文件

@ -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)

查看文件

@ -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,
*,

查看文件

@ -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:

查看文件

@ -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 = `<div class="persona-error">读取失败:${escapeHtml(err?.message || "未知错误")}</div>`;
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) {
</div>
`;
html += `
<div class="persona-card persona-card-wide">
<div class="persona-card-head"><b>情绪链路诊断</b><span class="persona-badge">${escapeHtml(traceDiagnostics.state || "degraded")}</span></div>
<div class="persona-card-body">
<div class="persona-event-list">
${traceItems.map((item) => `<button type="button" class="persona-event-item" data-memory-emotion-trace="${escapeHtml(item.trace_id || "")}"><b>${escapeHtml(item.event_type || "neutral")} · r${escapeHtml(item.revision || 1)}</b><small>${escapeHtml(item.status || "observed")} · ${escapeHtml(item.occurred_at || "")}</small></button>`).join("") || '<p class="persona-empty">暂无可展示的脱敏 trace。</p>'}
</div>
<pre class="json-box" data-memory-emotion-trace-detail>选择一条 trace 查看事件 revision 与投递确认状态。</pre>
</div>
</div>
`;
html += `
<div class="persona-card persona-card-wide">
<div class="persona-card-head">

查看文件

@ -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()