119 行
5.5 KiB
Python
119 行
5.5 KiB
Python
"""Redacted, read-only projection of the cross-plugin emotion pipeline."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import hashlib
|
|
from typing import Any
|
|
|
|
|
|
def _text(value: Any, limit: int) -> str:
|
|
return " ".join(str(value or "").split())[:limit]
|
|
|
|
|
|
def _hash(value: Any) -> str:
|
|
cleaned = _text(value, 220)
|
|
return hashlib.sha256(cleaned.encode("utf-8", errors="ignore")).hexdigest()[:12] if cleaned else ""
|
|
|
|
|
|
def _ref(value: Any) -> dict[str, str]:
|
|
source = value if isinstance(value, dict) else {}
|
|
return {"kind": _text(source.get("kind"), 24), "role": _text(source.get("role"), 40), "id_hash": _hash(source.get("id"))}
|
|
|
|
|
|
def emotion_trace_summary(user: Any, *, limit: int = 20) -> list[dict[str, Any]]:
|
|
source = user if isinstance(user, dict) else {}
|
|
ledger = source.get("emotion_event_ledger")
|
|
if not isinstance(ledger, list):
|
|
return []
|
|
latest: dict[str, dict[str, Any]] = {}
|
|
for event in ledger:
|
|
if not isinstance(event, dict):
|
|
continue
|
|
trace_id = _text(event.get("trace_id"), 96)
|
|
if not trace_id:
|
|
continue
|
|
previous = latest.get(trace_id)
|
|
if previous is None or int(event.get("revision") or 0) >= int(previous.get("revision") or 0):
|
|
latest[trace_id] = event
|
|
items = sorted(latest.values(), key=lambda item: (_text(item.get("occurred_at"), 48), int(item.get("revision") or 0)), reverse=True)
|
|
return [{
|
|
"trace_id": _text(item.get("trace_id"), 96),
|
|
"event_id": _text(item.get("event_id"), 96),
|
|
"revision": max(1, int(item.get("revision") or 1)),
|
|
"event_type": _text(item.get("event_type"), 48),
|
|
"status": _text(item.get("status"), 24),
|
|
"occurred_at": _text(item.get("occurred_at"), 48),
|
|
} for item in items[: max(1, min(100, int(limit or 20)))]]
|
|
|
|
|
|
def build_emotion_trace_projection(
|
|
user: Any,
|
|
trace_id: str,
|
|
*,
|
|
daily_state: Any = None,
|
|
expression_decision: Any = None,
|
|
memory_result: Any = None,
|
|
requester_context: Any = None,
|
|
) -> dict[str, Any]:
|
|
context = requester_context if isinstance(requester_context, dict) else {}
|
|
if context.get("is_admin") is not True:
|
|
return {"state": "forbidden", "read_only": True, "trace_id": "", "events": [], "error_code": "admin_required"}
|
|
source = user if isinstance(user, dict) else {}
|
|
trace = _text(trace_id, 96)
|
|
ledger = source.get("emotion_event_ledger")
|
|
local_events = []
|
|
for event in ledger if isinstance(ledger, list) else []:
|
|
if not isinstance(event, dict) or event.get("trace_id") != trace:
|
|
continue
|
|
local_events.append({
|
|
"event_id": _text(event.get("event_id"), 96),
|
|
"trace_id": trace,
|
|
"revision": max(1, int(event.get("revision") or 1)),
|
|
"origin_kind": _text(event.get("origin_kind"), 40),
|
|
"event_type": _text(event.get("event_type"), 48),
|
|
"intensity": float(event.get("intensity") or 0.0),
|
|
"confidence": float(event.get("confidence") or 0.0),
|
|
"status": _text(event.get("status"), 24),
|
|
"source_rule": _text(event.get("source_rule"), 80),
|
|
"occurred_at": _text(event.get("occurred_at"), 48),
|
|
"applied_interaction": _text(event.get("applied_interaction"), 32),
|
|
"correction_of": _text(event.get("correction_of"), 96),
|
|
"actor": _ref(event.get("actor_ref")),
|
|
"target": _ref(event.get("target_ref")),
|
|
"quoted_target": _ref(event.get("quoted_target_ref")),
|
|
})
|
|
local_events.sort(key=lambda item: item["revision"])
|
|
state = daily_state if isinstance(daily_state, dict) else {}
|
|
conditions = state.get("conditions") if isinstance(state.get("conditions"), list) else []
|
|
afterglow = [{
|
|
"condition_id": _text(item.get("id"), 120),
|
|
"source_event_id": _text(item.get("source_event_id"), 96),
|
|
"source_revision": max(1, int(item.get("source_revision") or 1)),
|
|
"energy_delta": float(item.get("energy_delta") or 0.0),
|
|
"start_ts": float(item.get("start_ts") or 0.0),
|
|
"end_ts": float(item.get("end_ts") or 0.0),
|
|
"half_life_seconds": float(item.get("half_life_seconds") or 0.0),
|
|
} for item in conditions if isinstance(item, dict) and item.get("kind") == "memory_afterglow" and (not trace or item.get("trace_id") == trace)]
|
|
memory = memory_result if isinstance(memory_result, dict) else {}
|
|
memory_items = memory.get("items") if isinstance(memory.get("items"), list) else []
|
|
return {
|
|
"schema_version": "emotion_trace_projection.v1",
|
|
"state": "ready" if memory.get("state") in {None, "ready"} else "degraded",
|
|
"read_only": True,
|
|
"trace_id": trace,
|
|
"events": local_events,
|
|
"memory_events": memory_items[:100],
|
|
"current_interaction": source.get("current_interaction") if isinstance(source.get("current_interaction"), dict) else {},
|
|
"afterglow": afterglow[:20],
|
|
"daily_state": {
|
|
"mood_bias": _text(state.get("mood_bias"), 40),
|
|
"energy": max(0, min(100, int(state.get("energy") or 0))),
|
|
"affect_modulation": state.get("affect_modulation") if isinstance(state.get("affect_modulation"), dict) else {},
|
|
},
|
|
"expression_decision": expression_decision if isinstance(expression_decision, dict) else {},
|
|
"memory_state": _text(memory.get("state"), 24) or "degraded",
|
|
"error_code": _text(memory.get("error_code"), 80),
|
|
}
|
|
|
|
|
|
__all__ = ["build_emotion_trace_projection", "emotion_trace_summary"]
|