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]]: 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) 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]]: 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.""" """Search for unresolved open-loop / promise memories for proactive companionship."""
return await self._plugin.bridge_search_open_loops(session_id=session_id, limit=limit) return await self._plugin.bridge_search_open_loops(session_id=session_id, limit=limit)

查看文件

@ -1,6 +1,7 @@
from __future__ import annotations from __future__ import annotations
import asyncio import asyncio
import hashlib
from contextlib import closing, contextmanager from contextlib import closing, contextmanager
from copy import deepcopy from copy import deepcopy
import re import re
@ -5638,6 +5639,166 @@ class MemoryStore:
).fetchall() ).fetchall()
return [self._emotion_event_row(row) for row in rows] 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( async def list_emotion_events(
self, self,
*, *,

查看文件

@ -79,6 +79,8 @@ class PluginPageApi:
("/config/module/update", self.config_module_update, ["POST"], "MemoryCompanion Page config module update"), ("/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"), ("/retrieval/config/update", self.retrieval_config_update, ["POST"], "MemoryCompanion Page retrieval config update"),
("/operations/diagnostics", self.operations_diagnostics, ["GET"], "MemoryCompanion operations diagnostics"), ("/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"), ("/coordination/status", self.coordination_status, ["GET"], "MemoryCompanion safe coordination status"),
("/operations/preset", self.operations_preset, ["GET", "POST"], "MemoryCompanion operations preset"), ("/operations/preset", self.operations_preset, ["GET", "POST"], "MemoryCompanion operations preset"),
("/data/export", self.data_export, ["POST"], "MemoryCompanion portable data export"), ("/data/export", self.data_export, ["POST"], "MemoryCompanion portable data export"),
@ -195,6 +197,39 @@ class PluginPageApi:
except Exception as exc: except Exception as exc:
return self._err(f"运维诊断失败: {exc}", 500) 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): async def coordination_status(self):
"""Expose a fixed, read-only coordination projection.""" """Expose a fixed, read-only coordination projection."""
try: try:

查看文件

@ -6231,11 +6231,32 @@ async function loadPersonaState() {
let data; let data;
try { try {
data = await apiGet("/persona-state"); 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) { } catch (err) {
panel.innerHTML = `<div class="persona-error">读取失败:${escapeHtml(err?.message || "未知错误")}</div>`; panel.innerHTML = `<div class="persona-error">读取失败:${escapeHtml(err?.message || "未知错误")}</div>`;
return; return;
} }
panel.innerHTML = renderPersonaState(data || {}); 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) { function renderPersonaState(d) {
@ -6246,6 +6267,8 @@ function renderPersonaState(d) {
const timeOfDay = d.time_of_day || ""; const timeOfDay = d.time_of_day || "";
const legacyLabels = d.legacy_context_labels || {}; const legacyLabels = d.legacy_context_labels || {};
const timeLabels = d.time_of_day_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 timeLabel = timeLabels[timeOfDay] || timeOfDay || "未知";
const crossTotal = crossState.total || 0; const crossTotal = crossState.total || 0;
@ -6275,6 +6298,18 @@ function renderPersonaState(d) {
</div> </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 += ` html += `
<div class="persona-card persona-card-wide"> <div class="persona-card persona-card-wide">
<div class="persona-card-head"> <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()