feat: add P3 orchestration and P4 boundary coverage

这个提交存在于:
YokiiroBW 2026-07-29 21:33:29 +08:00
父节点 5c8cffdf06
当前提交 72273e1ffb
共有 9 个文件被更改,包括 1012 次插入 和 63 次删除

查看文件

@ -5,6 +5,7 @@ from typing import Any
from zoneinfo import ZoneInfo from zoneinfo import ZoneInfo
from .models import EntityRef, MemoryRecord, SessionContext, clean_text from .models import EntityRef, MemoryRecord, SessionContext, clean_text
from .identity import session_target_id
from .archive_contract import user_fact_query_capabilities from .archive_contract import user_fact_query_capabilities
from .ops_domain import OpsDomainContract, normalize_ops_audit, normalize_ops_event, normalize_ops_task from .ops_domain import OpsDomainContract, normalize_ops_audit, normalize_ops_event, normalize_ops_task
from .temporal_context import build_reply_delay, build_temporal_memory_meta from .temporal_context import build_reply_delay, build_temporal_memory_meta
@ -13,6 +14,7 @@ from .unified_person_contract import (
contract_capabilities, contract_capabilities,
) )
from .person_memory_contract import capabilities as person_memory_capabilities, consume_person_memory_envelope from .person_memory_contract import capabilities as person_memory_capabilities, consume_person_memory_envelope
from .context_orchestration import contract_descriptor, contract_fingerprint
LOCAL_TZ = ZoneInfo("Asia/Shanghai") LOCAL_TZ = ZoneInfo("Asia/Shanghai")
@ -42,6 +44,44 @@ class MemoryCompanionBridge:
def __init__(self, plugin: Any): def __init__(self, plugin: Any):
self._plugin = plugin self._plugin = plugin
def _trusted_session_context(self, session_context: SessionContext | dict[str, Any] | None) -> SessionContext | dict[str, Any] | None:
"""Normalize a legacy dict at the public bridge boundary.
``legacy_local`` is intentionally minted only here. Direct service
calls carrying a dict remain P3-unavailable, while this in-process
compatibility path remains confined to one verified session.
"""
if not isinstance(session_context, dict):
return session_context
normalizer = getattr(self._plugin, "session_context_from_bridge", None)
if not callable(normalizer):
return session_context
ctx = normalizer(dict(session_context))
if not isinstance(ctx, SessionContext) or ctx.context_orchestration_status != "unavailable":
return ctx
has_p2_or_person_payload = any(
key in session_context and session_context[key] is not None
for key in (
"unified_person_projection", "unified_person_source_identity",
"person_memory_envelope", "unified_person_id", "person_id",
)
)
if (
not has_p2_or_person_payload
and ctx.scope in {"private", "group"}
and bool(
session_target_id(ctx.session_id, ctx.scope)
or clean_text(ctx.session_id, 200).startswith(f"{ctx.scope}:")
and clean_text(ctx.session_id, 200)[len(ctx.scope) + 1:]
)
):
ctx.strict_session_only = True
ctx.context_orchestration_status = "legacy_local"
marker = getattr(self._plugin, "_p3_mark_trusted_legacy_context", None)
if callable(marker):
marker(ctx)
return ctx
def probe_runtime_capabilities(self) -> dict[str, Any]: def probe_runtime_capabilities(self) -> dict[str, Any]:
capabilities = getattr(self._plugin, "runtime_capabilities", None) capabilities = getattr(self._plugin, "runtime_capabilities", None)
if capabilities is None: if capabilities is None:
@ -68,6 +108,15 @@ class MemoryCompanionBridge:
"""Expose the read-only unified-person consumer contract.""" """Expose the read-only unified-person consumer contract."""
return contract_capabilities() return contract_capabilities()
def probe_context_orchestration_capabilities(self) -> dict[str, Any]:
return {
"available": True,
"contract": contract_descriptor(),
"contract_fingerprint": contract_fingerprint(),
"bridge_requires_verified_core_for_high_risk": True,
"legacy_local_same_session_only": True,
}
def consume_unified_person_projection( def consume_unified_person_projection(
self, self,
projection: dict[str, Any] | None, projection: dict[str, Any] | None,
@ -561,7 +610,11 @@ class MemoryCompanionBridge:
session_context: SessionContext | dict[str, Any] | None = None, session_context: SessionContext | dict[str, Any] | None = None,
top_k: int | None = None, top_k: int | None = None,
) -> list[dict[str, Any]]: ) -> list[dict[str, Any]]:
return await self._plugin.bridge_search(query, session_context=session_context, top_k=top_k) return await self._plugin.bridge_search(
query,
session_context=self._trusted_session_context(session_context),
top_k=top_k,
)
def probe_archive_capabilities(self) -> dict[str, Any]: def probe_archive_capabilities(self) -> dict[str, Any]:
return self._plugin.bridge_probe_archive_capabilities() return self._plugin.bridge_probe_archive_capabilities()
@ -652,7 +705,7 @@ class MemoryCompanionBridge:
) -> str: ) -> str:
return await self._plugin.bridge_compose_injection( return await self._plugin.bridge_compose_injection(
query, query,
session_context=session_context, session_context=self._trusted_session_context(session_context),
top_k=top_k, top_k=top_k,
max_chars=max_chars, max_chars=max_chars,
companion_bot_mood=companion_bot_mood, companion_bot_mood=companion_bot_mood,
@ -689,7 +742,7 @@ class MemoryCompanionBridge:
) -> str: ) -> str:
return await self._plugin.bridge_compose_context( return await self._plugin.bridge_compose_context(
query=query, query=query,
session_context=session_context, session_context=self._trusted_session_context(session_context),
top_k=top_k, top_k=top_k,
max_chars=max_chars, max_chars=max_chars,
companion_bot_mood=companion_bot_mood, companion_bot_mood=companion_bot_mood,

查看文件

@ -0,0 +1,192 @@
# -*- coding: utf-8 -*-
"""P3 versioned, metadata-only request context contract."""
from __future__ import annotations
import hashlib
import json
import re
from copy import deepcopy
from datetime import datetime, timezone
from typing import Any
CONTRACT_NAME = "ops.context_orchestration.v1"
CONTRACT_VERSION = "1.0"
ATTRIBUTE_NAME = "_ops_context_orchestration_v1"
LAYERS = ("persona", "runtime", "person", "scene", "memory", "safety")
PHASES = ("initialized", "companion_ready", "memory_ready", "safety_ready", "finalized", "invalid")
SECURITY_STATUSES = ("allowed", "sanitized", "blocked", "quarantined", "unavailable")
POLICIES = ("inherit", "allow", "deny", "quarantine")
TRUST_LEVELS = ("T0", "T1", "T2", "T3", "T4")
CONTEXT_INIT, COMPANION_CONTEXT, TTS_FALLBACK, MEMORY_CONTEXT = 100, 0, -10, -20
INCOMPATIBLE_TOOL, SENSITIVE_TOOL, FINALIZE = -20000, -21000, -22000
MAX_FRAGMENTS, MAX_ERRORS, MAX_REASON_CODES = 64, 16, 16
_FRAGMENT_FIELDS = ("key", "layer", "source", "trust_level", "content_hash", "chars", "status")
_CORE = ("persona", "runtime", "person", "scene")
_STATE_FIELDS = {"contract_name", "contract_version", "contract_fingerprint", "request_id", "session_id", "scope", "created_at", "phase", "completed_layers", "fragments", "security", "errors", "finalized"}
_SECURITY_FIELDS = {"status", "event_id", "memory_policy", "tool_policy", "response_policy", "reason_codes"}
_CODE_RE = re.compile(r"^[a-z0-9][a-z0-9_.:-]{0,119}$")
def _json(value: Any) -> str:
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
def contract_descriptor(*, fixture_version: str = "1") -> dict[str, Any]:
return {"contract_name": CONTRACT_NAME, "contract_version": CONTRACT_VERSION, "attribute_name": ATTRIBUTE_NAME, "fixture_version": str(fixture_version), "layers": list(LAYERS), "phases": list(PHASES), "security_statuses": list(SECURITY_STATUSES), "policies": list(POLICIES), "trust_levels": list(TRUST_LEVELS), "state_fields": ["contract_name", "contract_version", "contract_fingerprint", "request_id", "session_id", "scope", "created_at", "phase", "completed_layers", "fragments", "security", "errors", "finalized"], "security_fields": ["status", "event_id", "memory_policy", "tool_policy", "response_policy", "reason_codes"], "fragment_fields": list(_FRAGMENT_FIELDS), "limits": {"fragments": MAX_FRAGMENTS, "errors": MAX_ERRORS, "reason_codes": MAX_REASON_CODES}}
def contract_fingerprint(*, fixture_version: str = "1") -> str:
return hashlib.sha256(_json(contract_descriptor(fixture_version=fixture_version)).encode("utf-8")).hexdigest()
def _text(value: Any, limit: int = 240) -> str:
return str(value or "").replace("\r", " ").replace("\n", " ").strip()[:limit]
def _utc_timestamp(value: Any = None) -> str:
if value is None:
return datetime.now(timezone.utc).isoformat(timespec="milliseconds").replace("+00:00", "Z")
if not isinstance(value, str) or value != value.strip() or "T" not in value or not value.endswith("Z"):
return ""
try:
datetime.fromisoformat(value[:-1] + "+00:00")
except ValueError:
return ""
return value
def _security() -> dict[str, Any]:
return {"status": "allowed", "event_id": "", "memory_policy": "inherit", "tool_policy": "inherit", "response_policy": "inherit", "reason_codes": []}
def new_context_state(*, request_id: Any = "", session_id: Any = "", scope: Any = "unknown", created_at: Any = None, fixture_version: str = "1") -> dict[str, Any]:
return {"contract_name": CONTRACT_NAME, "contract_version": CONTRACT_VERSION, "contract_fingerprint": contract_fingerprint(fixture_version=fixture_version), "request_id": _text(request_id, 180), "session_id": _text(session_id), "scope": _text(scope, 80) or "unknown", "created_at": _utc_timestamp(created_at), "phase": "initialized", "completed_layers": [], "fragments": [], "security": _security(), "errors": [], "finalized": False}
def _error(state: dict[str, Any], code: str) -> None:
errors = state.setdefault("errors", [])
if isinstance(errors, list) and code not in errors and len(errors) < MAX_ERRORS:
errors.append(code)
def _invalid(state: dict[str, Any], code: str) -> dict[str, Any]:
_error(state, code); state["phase"] = "invalid"; state["finalized"] = False
return state
def consume_context_state(value: Any, *, fixture_version: str = "1") -> dict[str, Any] | None:
if not isinstance(value, dict): return None
state = value
if state.get("contract_name") != CONTRACT_NAME or state.get("contract_version") != CONTRACT_VERSION: return _invalid(state, "contract_mismatch")
if state.get("contract_fingerprint") != contract_fingerprint(fixture_version=fixture_version): return _invalid(state, "fingerprint_mismatch")
if set(state) != _STATE_FIELDS or state.get("phase") not in PHASES or not isinstance(state.get("finalized"), bool): return _invalid(state, "state_invalid")
if not isinstance(state.get("created_at"), str) or not state["created_at"] or _utc_timestamp(state["created_at"]) != state["created_at"]: return _invalid(state, "created_at_invalid")
completed = state.get("completed_layers")
if not isinstance(completed, list): return _invalid(state, "state_invalid")
if any(layer not in LAYERS for layer in completed) or len(completed) != len(set(completed)) or completed != sorted(completed, key=LAYERS.index): return _invalid(state, "completed_layers_invalid")
if state["finalized"] != (state["phase"] == "finalized"): return _invalid(state, "finalized_phase_invalid")
if state["finalized"] and set(completed) != set(LAYERS): return _invalid(state, "finalized_layers_invalid")
if not isinstance(state.get("fragments"), list) or len(state["fragments"]) > MAX_FRAGMENTS: return _invalid(state, "fragments_invalid")
for fragment in state["fragments"]:
if not isinstance(fragment, dict) or set(fragment) != set(_FRAGMENT_FIELDS) or fragment.get("layer") not in LAYERS or fragment.get("trust_level") not in TRUST_LEVELS: return _invalid(state, "fragment_invalid")
security = state.get("security")
if not isinstance(security, dict) or set(security) != _SECURITY_FIELDS or security.get("status") not in SECURITY_STATUSES or any(security.get(key) not in POLICIES for key in ("memory_policy", "tool_policy", "response_policy")): return _invalid(state, "security_invalid")
errors = state.get("errors")
reason_codes = security.get("reason_codes")
if not isinstance(reason_codes, list) or len(reason_codes) > MAX_REASON_CODES or not isinstance(errors, list) or len(errors) > MAX_ERRORS: return _invalid(state, "limits_invalid")
if any(not isinstance(code, str) or _CODE_RE.fullmatch(code) is None for code in [*errors, *reason_codes]): return _invalid(state, "codes_invalid")
return state
def attach_context_state(state: dict[str, Any], request: Any | None = None, event: Any | None = None) -> dict[str, Any]:
for carrier in (request, event):
if carrier is not None:
try: setattr(carrier, ATTRIBUTE_NAME, state)
except Exception: pass
return state
def read_context_state(request: Any | None = None, event: Any | None = None, *, fixture_version: str = "1") -> dict[str, Any] | None:
for carrier in (request, event):
state = consume_context_state(getattr(carrier, ATTRIBUTE_NAME, None) if carrier is not None else None, fixture_version=fixture_version)
if state is not None:
attach_context_state(state, request, event)
return state
return None
def _refresh(state: dict[str, Any]) -> None:
if state["phase"] == "invalid" or state["finalized"]: return
completed = set(state["completed_layers"])
state["phase"] = "safety_ready" if "safety" in completed else "memory_ready" if "memory" in completed else "companion_ready" if set(_CORE).issubset(completed) else "initialized"
def _open(state: dict[str, Any]) -> bool:
return consume_context_state(state) is not None and state.get("phase") != "invalid" and not state.get("finalized")
def complete_layer(state: dict[str, Any], layer: str) -> dict[str, Any]:
if not _open(state): return state
if layer not in LAYERS: return _invalid(state, "layer_invalid")
if layer not in state["completed_layers"]:
state["completed_layers"].append(layer)
state["completed_layers"].sort(key=LAYERS.index)
_refresh(state); return state
def register_fragment(state: dict[str, Any], *, key: Any, layer: str, source: Any = "", trust_level: str = "T2", content: Any = None, content_hash: Any = "", chars: Any = None, status: Any = "allowed") -> dict[str, Any]:
if not _open(state): return state
if layer not in LAYERS or trust_level not in TRUST_LEVELS: return _invalid(state, "fragment_invalid")
raw = "" if content is None else str(content)
try: size = max(0, int(len(raw) if chars is None else chars))
except (TypeError, ValueError): return _invalid(state, "fragment_chars_invalid")
item = {"key": _text(key, 120) or "fragment", "layer": layer, "source": _text(source, 120), "trust_level": trust_level, "content_hash": _text(content_hash, 128) or hashlib.sha256(raw.encode("utf-8")).hexdigest(), "chars": size, "status": _text(status, 40) or "allowed"}
for old in state["fragments"]:
if old == item: return state
if old.get("key") == item["key"]: return _invalid(state, "fragment_key_conflict")
if len(state["fragments"]) >= MAX_FRAGMENTS: return _invalid(state, "fragment_limit")
state["fragments"].append(item); return state
def update_security(state: dict[str, Any], *, status: str | None = None, event_id: Any = None, memory_policy: str | None = None, tool_policy: str | None = None, response_policy: str | None = None, reason_codes: Any = None) -> dict[str, Any]:
if not _open(state): return state
security = state["security"]
if status is not None:
if status not in SECURITY_STATUSES: return _invalid(state, "security_status_invalid")
security["status"] = status
for key, value in (("memory_policy", memory_policy), ("tool_policy", tool_policy), ("response_policy", response_policy)):
if value is not None:
if value not in POLICIES: return _invalid(state, "security_policy_invalid")
security[key] = value
if event_id is not None: security["event_id"] = _text(event_id, 180)
codes = [reason_codes] if isinstance(reason_codes, str) else (reason_codes or [])
if not isinstance(codes, (list, tuple, set)): return _invalid(state, "reason_codes_invalid")
for code in codes:
if not isinstance(code, str) or _CODE_RE.fullmatch(code) is None: return _invalid(state, "reason_code_invalid")
if code not in security["reason_codes"] and len(security["reason_codes"]) < MAX_REASON_CODES: security["reason_codes"].append(code)
return state
def finalize_state(state: dict[str, Any]) -> dict[str, Any]:
if not _open(state): return state
if set(LAYERS).issubset(set(state["completed_layers"])):
state["phase"], state["finalized"] = "finalized", True
else:
_error(state, "finalize_pending_layers")
return state
def project_context_state(state: dict[str, Any] | None) -> dict[str, Any] | None:
state = consume_context_state(state)
if state is None: return None
return deepcopy({key: state[key] for key in ("contract_name", "contract_version", "contract_fingerprint", "request_id", "session_id", "scope", "created_at", "phase", "completed_layers", "fragments", "security", "errors", "finalized")})
def infer_context_layer(key: Any = "", source: Any = "") -> str:
text = f"{key or ''} {source or ''}".lower()
if any(token in text for token in ("memory", "recall")): return "memory"
if any(token in text for token in ("safety", "guard", "tool", "tts", "privacy", "sanitize")): return "safety"
if any(token in text for token in ("persona", "reply.style", "identity", "character")): return "persona"
if any(token in text for token in ("private.context", "preferred_address", "preferred address", "relationship", "nickname", "person", "user.")): return "person"
if any(token in text for token in ("runtime", "state", "schedule", "temporal", "weather", "food", "agenda", "time")): return "runtime"
return "scene"

查看文件

@ -119,6 +119,9 @@ class SessionContext:
person_id: str = "" person_id: str = ""
person_origin_identity_key: str = "" person_origin_identity_key: str = ""
person_identity_assurance: str = "" person_identity_assurance: str = ""
context_orchestration: dict[str, Any] = field(default_factory=dict)
context_orchestration_status: str = "unavailable"
context_orchestration_error: str = ""
@property @property
def current_target_id(self) -> str: def current_target_id(self) -> str:

查看文件

@ -60,6 +60,11 @@ from .chat_import import HistoricalChatImporter
from .classifier import MemoryClassifier from .classifier import MemoryClassifier
from .config import ConfigView from .config import ConfigView
from .context_orchestrator import RetrievalIntent, RetrievalIntentBuilder from .context_orchestrator import RetrievalIntent, RetrievalIntentBuilder
from .context_orchestration import (
ATTRIBUTE_NAME,
attach_context_state, complete_layer, consume_context_state, project_context_state,
read_context_state, register_fragment, update_security,
)
from .identity import IdentityResolver, looks_like_command, maybe_await, normalize_session_context_fields, session_target_id from .identity import IdentityResolver, looks_like_command, maybe_await, normalize_session_context_fields, session_target_id
from .importance import ImportanceEvaluator from .importance import ImportanceEvaluator
from .injection import ( from .injection import (
@ -339,10 +344,174 @@ class MemoryCompanionService:
async def rollback_historical_chat_import(self, batch_id: str) -> dict[str, Any]: async def rollback_historical_chat_import(self, batch_id: str) -> dict[str, Any]:
return await self.chat_importer.rollback_batch(batch_id) return await self.chat_importer.rollback_batch(batch_id)
def _p3_mark_trusted_legacy_context(self, ctx: SessionContext) -> None:
registry = getattr(self, "_p3_trusted_legacy_contexts", None)
if not isinstance(registry, dict):
registry = {}
self._p3_trusted_legacy_contexts = registry
registry[id(ctx)] = ctx
def _p3_take_trusted_legacy_context(self, ctx: SessionContext) -> bool:
registry = getattr(self, "_p3_trusted_legacy_contexts", {})
if not isinstance(registry, dict) or registry.get(id(ctx)) is not ctx:
return False
registry.pop(id(ctx), None)
return True
@staticmethod
def _p3_has_valid_session_id(ctx: SessionContext) -> bool:
session_id = clean_text(ctx.session_id, 200)
return bool(
session_target_id(session_id, ctx.scope)
or session_id.startswith(f"{ctx.scope}:") and session_id[len(ctx.scope) + 1:]
)
@staticmethod
def _p3_carrier_value(carrier: Any, key: str) -> Any:
if isinstance(carrier, dict):
return carrier.get(key)
return getattr(carrier, key, None) if carrier is not None else None
def _p3_prepare_context(self, ctx: SessionContext, *, event: Any = None, req: Any = None) -> dict[str, Any] | None:
raw_present = any(self._p3_carrier_value(carrier, ATTRIBUTE_NAME) is not None for carrier in (req, event) if carrier is not None)
state = read_context_state(request=req, event=event)
if state is None and isinstance(ctx.context_orchestration, dict) and ctx.context_orchestration:
state = consume_context_state(ctx.context_orchestration)
if state is None:
ctx.strict_session_only = True
ctx.context_orchestration = {}
if raw_present:
ctx.context_orchestration_status = "invalid"
ctx.context_orchestration_error = "invalid_context_orchestration"
else:
ctx.context_orchestration_status = "unavailable"
ctx.context_orchestration_error = ""
return None
projection = project_context_state(state)
ctx.context_orchestration = projection or {}
if state.get("phase") == "invalid":
ctx.context_orchestration_status = "invalid"
ctx.context_orchestration_error = "invalid_context_orchestration"
else:
ctx.context_orchestration_status = "accepted"
ctx.context_orchestration_error = ""
return state
def _p3_high_risk_context(self, ctx: SessionContext, *, event: Any = None, req: Any = None) -> bool:
if ctx.person_id or ctx.person_origin_identity_key or ctx.person_identity_assurance:
return True
for carrier in (req, event):
for key in (
"unified_person_projection", "unified_person_source_identity",
"person_memory_envelope", "unified_person_id", "person_id",
):
if self._p3_carrier_value(carrier, key):
return True
return False
def _p3_gate_reason(
self,
ctx: SessionContext,
*,
event: Any = None,
req: Any = None,
state: dict[str, Any] | None = None,
high_risk: bool | None = None,
require_contract: bool = False,
) -> str:
if state is None:
state = self._p3_prepare_context(ctx, event=event, req=req)
risk = self._p3_high_risk_context(ctx, event=event, req=req) if high_risk is None else bool(high_risk)
if state is None and ctx.context_orchestration_status == "invalid":
return "p3_invalid"
if state is None:
return "p3_unavailable" if require_contract or risk else ""
if state.get("phase") == "invalid":
return "p3_invalid"
security = state.get("security") if isinstance(state.get("security"), dict) else {}
status = str(security.get("status") or "unavailable")
if status in {"blocked", "quarantined", "unavailable"}:
return f"p3_security_{status}"
memory_policy = str(security.get("memory_policy") or "inherit")
if memory_policy in {"deny", "quarantine"}:
return f"p3_memory_policy_{memory_policy}"
if risk:
completed = set(state.get("completed_layers") or [])
if not {"persona", "runtime", "person", "scene"}.issubset(completed):
return "p3_core_incomplete"
if state.get("phase") not in {"companion_ready", "memory_ready", "safety_ready", "finalized"}:
return "p3_phase_not_ready"
return ""
def _p3_bridge_gate_reason(self, ctx: SessionContext) -> str:
state = consume_context_state(ctx.context_orchestration) if ctx.context_orchestration else None
if state is None:
ctx.strict_session_only = True
trusted_legacy = (
ctx.context_orchestration_status == "legacy_local"
and self._p3_take_trusted_legacy_context(ctx)
)
if (
trusted_legacy
and ctx.scope in {"private", "group"}
and self._p3_has_valid_session_id(ctx)
and not self._p3_high_risk_context(ctx)
):
return ""
return "p3_invalid" if ctx.context_orchestration_status == "invalid" else "p3_unavailable"
reason = self._p3_gate_reason(ctx, state=state, high_risk=True, require_contract=True)
if reason:
return reason
if state.get("phase") != "companion_ready":
return "p3_phase_not_companion_ready"
return ""
def _p3_mark_denied(self, state: dict[str, Any] | None, *, event: Any = None, req: Any = None, reason: str) -> None:
if state is not None:
update_security(state, memory_policy="deny", reason_codes=reason)
attach_context_state(state, request=req, event=event)
else:
carrier = event if event is not None else req
if carrier is not None:
try:
setattr(carrier, "_memory_companion_p3_gate_reason", reason)
except Exception:
pass
def _p3_complete_memory(self, state: dict[str, Any] | None, *, ctx: SessionContext, injection: str = "", event: Any = None, req: Any = None) -> None:
if state is None or state.get("phase") in {"invalid", "finalized"}:
return
security = state.get("security") if isinstance(state.get("security"), dict) else {}
if security.get("status") in {"blocked", "quarantined", "unavailable"}:
return
if security.get("memory_policy") in {"deny", "quarantine"}:
return
completed = set(state.get("completed_layers") or [])
if not {"persona", "runtime", "person", "scene"}.issubset(completed):
return
injection_text = str(injection or "")
register_fragment(
state, key="memory.injection", layer="memory", source="memory_companion",
trust_level="T1", content_hash=hashlib.sha256(injection_text.encode("utf-8")).hexdigest(),
chars=len(injection_text), status=str(security.get("status") or "allowed"),
)
complete_layer(state, "memory")
attach_context_state(state, request=req, event=event)
ctx.context_orchestration = project_context_state(state) or {}
ctx.context_orchestration_status = "accepted"
async def handle_llm_request(self, event: Any, req: Any) -> None: async def handle_llm_request(self, event: Any, req: Any) -> None:
ctx = await self.identity.resolve_event_context(event) ctx = await self.identity.resolve_event_context(event)
self._sanitize_session_context_message_text(ctx) self._sanitize_session_context_message_text(ctx)
self._apply_private_companion_preferred_address(ctx, req=req, event=event) self._apply_private_companion_preferred_address(ctx, req=req, event=event)
p3_state = self._p3_prepare_context(ctx, event=event, req=req)
p3_reason = self._p3_gate_reason(ctx, event=event, req=req, state=p3_state)
if p3_reason:
remove_temp_text(req, MEMORY_COMPANION_INJECTION_HEADER, MEMORY_COMPANION_INJECTION_FOOTER)
self._mark_memory_companion_injection_state(event, req, injected=False, conversation_memory=False, slot_map={})
self._p3_mark_denied(p3_state, event=event, req=req, reason=p3_reason)
logger.warning("[MemoryCompanion] P3 request denied: session=%s reason=%s", ctx.session_id, p3_reason)
return
if self._private_companion_internal_generation_event(event): if self._private_companion_internal_generation_event(event):
return return
if looks_like_command(ctx.message_text): if looks_like_command(ctx.message_text):
@ -364,7 +533,9 @@ class MemoryCompanionService:
# this memory plugin no longer advances relationship authority. # this memory plugin no longer advances relationship authority.
try: try:
await self.inject_memories(ctx, req, event=event) injection = await self.inject_memories(ctx, req, event=event)
if injection is not None:
self._p3_complete_memory(p3_state, ctx=ctx, injection=injection, event=event, req=req)
except Exception as exc: except Exception as exc:
logger.warning( logger.warning(
"[MemoryCompanion] 记忆注入失败,已放行本轮 LLM 请求: session=%s error=%s", "[MemoryCompanion] 记忆注入失败,已放行本轮 LLM 请求: session=%s error=%s",
@ -440,6 +611,11 @@ class MemoryCompanionService:
return return
ctx = await self.identity.resolve_event_context(event) ctx = await self.identity.resolve_event_context(event)
self._sanitize_session_context_message_text(ctx) self._sanitize_session_context_message_text(ctx)
p3_state = self._p3_prepare_context(ctx, event=event)
p3_reason = self._p3_gate_reason(ctx, event=event, state=p3_state)
if p3_reason:
self._p3_mark_denied(p3_state, event=event, reason=p3_reason)
return
if ctx.scope != "group": if ctx.scope != "group":
return return
if looks_like_command(ctx.message_text): if looks_like_command(ctx.message_text):
@ -493,6 +669,11 @@ class MemoryCompanionService:
return return
ctx = await self.identity.resolve_event_context(event) ctx = await self.identity.resolve_event_context(event)
p3_state = self._p3_prepare_context(ctx, event=event)
p3_reason = self._p3_gate_reason(ctx, event=event, state=p3_state)
if p3_reason:
self._p3_mark_denied(p3_state, event=event, reason=p3_reason)
return
if looks_like_command(ctx.message_text): if looks_like_command(ctx.message_text):
return return
record = self.classifier.from_bot_response(ctx, text) record = self.classifier.from_bot_response(ctx, text)
@ -699,6 +880,22 @@ class MemoryCompanionService:
metadata: dict[str, Any] | None = None, metadata: dict[str, Any] | None = None,
occurred_at: str = "", occurred_at: str = "",
) -> str: ) -> str:
event_metadata = dict(metadata or {})
p3_raw = event_metadata.get("context_orchestration")
p3_state = consume_context_state(p3_raw) if p3_raw is not None else None
gate_ctx = SessionContext(
session_id=clean_text(session_id, 200), scope=clean_text(scope, 40),
platform=clean_text(platform, 80), user_id=clean_text(user_id, 120),
group_id=clean_text(group_id, 120), context_orchestration=project_context_state(p3_state) or {},
)
high_risk = gate_ctx.scope == "group" or bool(event_metadata.get("unified_person_projection") or event_metadata.get("person_memory_envelope"))
reason = self._p3_gate_reason(gate_ctx, state=p3_state, high_risk=high_risk, require_contract=p3_raw is not None)
if reason:
return ""
if p3_state is not None:
event_metadata["context_orchestration"] = project_context_state(p3_state)
else:
event_metadata.pop("context_orchestration", None)
text = self._sanitize_visible_timeline_text(content) text = self._sanitize_visible_timeline_text(content)
if not text: if not text:
return "" return ""
@ -712,7 +909,6 @@ class MemoryCompanionService:
event_type = "user_message" event_type = "user_message"
subject_id = clean_text(user_id, 120) subject_id = clean_text(user_id, 120)
object_id = clean_text(group_id if scope == "group" else user_id, 120) object_id = clean_text(group_id if scope == "group" else user_id, 120)
event_metadata = dict(metadata or {})
if source: if source:
event_metadata.setdefault("source", clean_text(source, 80)) event_metadata.setdefault("source", clean_text(source, 80))
event_metadata.setdefault("timezone", clean_text(event_metadata.get("timezone"), 80) or "Asia/Shanghai") event_metadata.setdefault("timezone", clean_text(event_metadata.get("timezone"), 80) or "Asia/Shanghai")
@ -797,6 +993,23 @@ class MemoryCompanionService:
if not self.config.bool("private_companion_bridge.accept_external_records", True): if not self.config.bool("private_companion_bridge.accept_external_records", True):
raise RuntimeError("外部记息写入已关闭") raise RuntimeError("外部记息写入已关闭")
metadata = dict(kwargs.get("metadata") or {}) if isinstance(kwargs.get("metadata"), dict) else {}
kwargs["metadata"] = metadata
p3_raw = metadata.get("context_orchestration")
p3_state = consume_context_state(p3_raw) if p3_raw is not None else None
gate_ctx = SessionContext(
session_id=clean_text(kwargs.get("session_id"), 200), scope=clean_text(kwargs.get("scope"), 40),
platform=clean_text(kwargs.get("platform"), 80), group_id=clean_text(kwargs.get("group_id"), 120),
context_orchestration=project_context_state(p3_state) or {},
)
high_risk = gate_ctx.scope == "group" or bool(metadata.get("unified_person_projection") or metadata.get("person_memory_envelope") or metadata.get("person_id"))
reason = self._p3_gate_reason(gate_ctx, state=p3_state, high_risk=high_risk, require_contract=p3_raw is not None)
if reason:
raise UserMemoryBoundaryError(reason)
if p3_state is not None:
metadata["context_orchestration"] = project_context_state(p3_state)
else:
metadata.pop("context_orchestration", None)
explicit_id = clean_text(kwargs.pop("memory_id", "") or kwargs.pop("id", ""), 120) explicit_id = clean_text(kwargs.pop("memory_id", "") or kwargs.pop("id", ""), 120)
record = self.classifier.external_record(**kwargs) record = self.classifier.external_record(**kwargs)
memory_domain = clean_text(getattr(record, "memory_domain", ""), 60).lower() memory_domain = clean_text(getattr(record, "memory_domain", ""), 60).lower()
@ -1071,6 +1284,8 @@ class MemoryCompanionService:
top_k: int | None = None, top_k: int | None = None,
) -> list[dict[str, Any]]: ) -> list[dict[str, Any]]:
ctx = self.session_context_from_bridge(session_context) ctx = self.session_context_from_bridge(session_context)
if self._p3_bridge_gate_reason(ctx):
return []
results = await self.search(query, ctx, top_k or self.config.int("memory_injection.top_k", 6)) results = await self.search(query, ctx, top_k or self.config.int("memory_injection.top_k", 6))
return [serialize_memory(item.memory, item.score, item.reason) for item in results] return [serialize_memory(item.memory, item.score, item.reason) for item in results]
@ -1232,6 +1447,10 @@ class MemoryCompanionService:
) -> dict[str, Any]: ) -> dict[str, Any]:
ctx = self._archive_context(scope) ctx = self._archive_context(scope)
query_text = clean_text(query, 1400) query_text = clean_text(query, 1400)
gate_reason = self._p3_gate_reason(
ctx, state=consume_context_state(ctx.context_orchestration) if ctx.context_orchestration else None,
high_risk=True, require_contract=True,
)
base_response = { base_response = {
"archive_api_version": ARCHIVE_API_VERSION, "archive_api_version": ARCHIVE_API_VERSION,
"scope": await self.bridge_get_archive_scope(scope=scope), "scope": await self.bridge_get_archive_scope(scope=scope),
@ -1239,6 +1458,9 @@ class MemoryCompanionService:
"excluded": [], "excluded": [],
"warnings": [], "warnings": [],
} }
if gate_reason:
base_response["warnings"] = [gate_reason]
return base_response
if not query_text: if not query_text:
base_response["error"] = "empty_query_denied" base_response["error"] = "empty_query_denied"
base_response["warnings"] = ["archive search requires a non-empty query"] base_response["warnings"] = ["archive search requires a non-empty query"]
@ -1294,6 +1516,16 @@ class MemoryCompanionService:
include_timeline: bool = True, include_timeline: bool = True,
) -> dict[str, Any]: ) -> dict[str, Any]:
ctx = self._archive_context(scope) ctx = self._archive_context(scope)
gate_reason = self._p3_gate_reason(
ctx, state=consume_context_state(ctx.context_orchestration) if ctx.context_orchestration else None,
high_risk=True, require_contract=True,
)
if gate_reason:
return {
"archive_api_version": "1.0",
"scope": await self.bridge_get_archive_scope(scope=scope),
"memories": [], "excluded": [], "warnings": [gate_reason],
}
policy = self.archive_visibility_policy() policy = self.archive_visibility_policy()
requested = [clean_text(item, 200) for item in memory_ids if clean_text(item, 200)] requested = [clean_text(item, 200) for item in memory_ids if clean_text(item, 200)]
records = await self.store.get_memories_by_ids([item for item in requested if not item.startswith("timeline_")]) records = await self.store.get_memories_by_ids([item for item in requested if not item.startswith("timeline_")])
@ -1350,8 +1582,21 @@ class MemoryCompanionService:
"archive_api_version": ARCHIVE_API_VERSION, "archive_api_version": ARCHIVE_API_VERSION,
} }
ctx = self._archive_context(scope) ctx = self._archive_context(scope)
archive_state = consume_context_state(ctx.context_orchestration) if ctx.context_orchestration else None
gate_reason = self._p3_gate_reason(
ctx, state=archive_state, high_risk=True, require_contract=True,
)
if gate_reason:
return {
"ok": False,
"error": gate_reason,
"archive_api_version": ARCHIVE_API_VERSION,
"memory_id": "",
"operation_id": operation,
}
safe_metadata = dict(metadata or {}) safe_metadata = dict(metadata or {})
safe_metadata.update({"source": "memory_archivist", "operation_id": operation}) safe_metadata.update({"source": "memory_archivist", "operation_id": operation})
safe_metadata["context_orchestration"] = project_context_state(archive_state)
memory_id = await self.record_external_event( memory_id = await self.record_external_event(
content=text, content=text,
memory_type="archive_summary", memory_type="archive_summary",
@ -1384,6 +1629,17 @@ class MemoryCompanionService:
include_timeline: bool = True, include_timeline: bool = True,
) -> dict[str, Any]: ) -> dict[str, Any]:
ctx = self._archive_context(scope) ctx = self._archive_context(scope)
gate_reason = self._p3_gate_reason(
ctx, state=consume_context_state(ctx.context_orchestration) if ctx.context_orchestration else None,
high_risk=True, require_contract=True,
)
if gate_reason:
return {
"archive_api_version": "1.0",
"scope": await self.bridge_get_archive_scope(scope=scope),
"start_at": clean_text(start_at, 80), "end_at": clean_text(end_at, 80),
"items": [], "warnings": [gate_reason],
}
policy = self.archive_visibility_policy() policy = self.archive_visibility_policy()
items: list[dict[str, Any]] = [] items: list[dict[str, Any]] = []
if include_timeline: if include_timeline:
@ -1440,6 +1696,8 @@ class MemoryCompanionService:
companion_bot_energy: float = 0.0, companion_bot_energy: float = 0.0,
) -> str: ) -> str:
ctx = self.session_context_from_bridge(session_context) ctx = self.session_context_from_bridge(session_context)
if self._p3_bridge_gate_reason(ctx):
return ""
query_text = clean_text(query or ctx.message_text, 1400) query_text = clean_text(query or ctx.message_text, 1400)
if not query_text: if not query_text:
return "" return ""
@ -1508,6 +1766,8 @@ class MemoryCompanionService:
) -> str: ) -> str:
started = time.monotonic() started = time.monotonic()
ctx = self._normalized_session_context(self.session_context_from_bridge(session_context)) ctx = self._normalized_session_context(self.session_context_from_bridge(session_context))
if self._p3_bridge_gate_reason(ctx):
return ""
query_text = clean_text(query or ctx.message_text, 1400) query_text = clean_text(query or ctx.message_text, 1400)
if not query_text: if not query_text:
return "" return ""
@ -1749,52 +2009,8 @@ class MemoryCompanionService:
async def bridge_search_open_loops(self, *, session_id: str = "", limit: int = 3) -> list[dict[str, Any]]: async def bridge_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."""
ctx = SessionContext(session_id=session_id or "", scope="private") # This legacy API has no carrier for the verified P3 contract.
try:
results = await self.search(
"约定 承诺 下次 继续 没完成 待续 还没 回头",
ctx,
top_k=max(limit * 3, 6),
)
except Exception:
return [] return []
open_loops: list[dict[str, Any]] = []
now = time.time()
for item in results:
memory = item.memory
metadata = memory.metadata if isinstance(memory.metadata, dict) else {}
try:
open_loop_w = float(metadata.get("open_loop_weight") or 0.0)
promise_w = float(metadata.get("promise_weight") or 0.0)
except Exception:
open_loop_w = promise_w = 0.0
if max(open_loop_w, promise_w) < 0.30:
continue
if metadata.get("resolved_at"):
continue
occurred = clean_text(memory.occurred_at or memory.created_at, 40)
age_days = None
if occurred:
try:
dt = datetime.fromisoformat(occurred.replace("Z", "+00:00"))
age_days = (now - dt.timestamp()) / 86400.0
except Exception:
pass
if age_days is not None and age_days < 0.5:
continue
open_loops.append({
"memory_id": memory.id,
"content": clean_text(memory.content, 300),
"session_id": memory.session_id,
"occurred_at": occurred,
"age_days": round(age_days, 1) if age_days is not None else None,
"open_loop_weight": round(open_loop_w, 3),
"promise_weight": round(promise_w, 3),
"memory_reason": clean_text(metadata.get("memory_reason"), 200),
})
if len(open_loops) >= limit:
break
return open_loops
def _detect_and_queue_emotional_events( def _detect_and_queue_emotional_events(
self, self,
@ -2994,6 +3210,9 @@ class MemoryCompanionService:
person_id=ctx.person_id, person_id=ctx.person_id,
person_origin_identity_key=ctx.person_origin_identity_key, person_origin_identity_key=ctx.person_origin_identity_key,
person_identity_assurance=ctx.person_identity_assurance, person_identity_assurance=ctx.person_identity_assurance,
context_orchestration=deepcopy(ctx.context_orchestration),
context_orchestration_status=ctx.context_orchestration_status,
context_orchestration_error=ctx.context_orchestration_error,
) )
def _bot_entity(self, ctx: SessionContext | None = None) -> EntityRef: def _bot_entity(self, ctx: SessionContext | None = None) -> EntityRef:
@ -3006,6 +3225,8 @@ class MemoryCompanionService:
def _schedule_session_summary(self, ctx: SessionContext, *, reason: str) -> None: def _schedule_session_summary(self, ctx: SessionContext, *, reason: str) -> None:
if not self.config.bool("memory_summary.enabled", True): if not self.config.bool("memory_summary.enabled", True):
return return
if self._p3_gate_reason(ctx, state=consume_context_state(ctx.context_orchestration) if ctx.context_orchestration else None):
return
snapshot = self._snapshot_context(ctx) snapshot = self._snapshot_context(ctx)
self._spawn_background(self._background_summarize_session(snapshot, reason), label=f"summary:{reason}") self._spawn_background(self._background_summarize_session(snapshot, reason), label=f"summary:{reason}")
@ -3094,6 +3315,8 @@ class MemoryCompanionService:
return min(base * (2**exponent), cooldown) if cooldown > 0 else base * (2**exponent) return min(base * (2**exponent), cooldown) if cooldown > 0 else base * (2**exponent)
async def maybe_summarize_session(self, ctx: SessionContext, *, force: bool = False) -> str: async def maybe_summarize_session(self, ctx: SessionContext, *, force: bool = False) -> str:
if self._p3_gate_reason(ctx, state=consume_context_state(ctx.context_orchestration) if ctx.context_orchestration else None):
return ""
if not force and not self.config.bool("memory_summary.enabled", True): if not force and not self.config.bool("memory_summary.enabled", True):
return "" return ""
if not ctx.session_id: if not ctx.session_id:
@ -3705,6 +3928,9 @@ class MemoryCompanionService:
async def search_for_event(self, event: Any, query: str, top_k: int = 6): async def search_for_event(self, event: Any, query: str, top_k: int = 6):
ctx = await self.identity.resolve_event_context(event) ctx = await self.identity.resolve_event_context(event)
state = self._p3_prepare_context(ctx, event=event)
if self._p3_gate_reason(ctx, event=event, state=state):
return []
time_intent = parse_time_intent(query or ctx.message_text) time_intent = parse_time_intent(query or ctx.message_text)
retrieval_query = self._query_for_time_intent(query, time_intent) retrieval_query = self._query_for_time_intent(query, time_intent)
return await self.search( return await self.search(
@ -3716,6 +3942,9 @@ class MemoryCompanionService:
async def explain_for_event(self, event: Any, query: str, top_k: int = 6): async def explain_for_event(self, event: Any, query: str, top_k: int = 6):
ctx = await self.identity.resolve_event_context(event) ctx = await self.identity.resolve_event_context(event)
state = self._p3_prepare_context(ctx, event=event)
if self._p3_gate_reason(ctx, event=event, state=state):
return [], []
time_intent = parse_time_intent(query or ctx.message_text) time_intent = parse_time_intent(query or ctx.message_text)
retrieval_query = self._query_for_time_intent(query, time_intent) retrieval_query = self._query_for_time_intent(query, time_intent)
return await self.search_with_diagnostics( return await self.search_with_diagnostics(
@ -3727,6 +3956,11 @@ class MemoryCompanionService:
async def explain_context_for_event(self, event: Any, query: str, top_k: int = 6): async def explain_context_for_event(self, event: Any, query: str, top_k: int = 6):
ctx = await self.identity.resolve_event_context(event) ctx = await self.identity.resolve_event_context(event)
state = self._p3_prepare_context(ctx, event=event)
reason = self._p3_gate_reason(ctx, event=event, state=state)
if reason:
intent = self.intent_builder.build(ctx, event=event, explicit_query=query)
return intent, [], [{"reason": reason}], {}
time_intent = parse_time_intent(query or ctx.message_text) time_intent = parse_time_intent(query or ctx.message_text)
intent = self.intent_builder.build( intent = self.intent_builder.build(
ctx, ctx,
@ -3748,6 +3982,9 @@ class MemoryCompanionService:
async def add_manual_memory(self, event: Any, content: str) -> str: async def add_manual_memory(self, event: Any, content: str) -> str:
ctx = await self.identity.resolve_event_context(event) ctx = await self.identity.resolve_event_context(event)
state = self._p3_prepare_context(ctx, event=event)
if self._p3_gate_reason(ctx, event=event, state=state):
return ""
visibility = "internal" visibility = "internal"
if ctx.scope == "private": if ctx.scope == "private":
visibility = "private_pair" visibility = "private_pair"
@ -3780,6 +4017,10 @@ class MemoryCompanionService:
async def tool_remember(self, event: Any, content: str, *, note_type: str = "memory") -> dict[str, Any]: async def tool_remember(self, event: Any, content: str, *, note_type: str = "memory") -> dict[str, Any]:
ctx = await self.identity.resolve_event_context(event) ctx = await self.identity.resolve_event_context(event)
state = self._p3_prepare_context(ctx, event=event)
reason = self._p3_gate_reason(ctx, event=event, state=state)
if reason:
return {"ok": False, "error": reason}
content = clean_text(content, 3000) content = clean_text(content, 3000)
note_type = clean_text(note_type, 40) or "memory" note_type = clean_text(note_type, 40) or "memory"
if not content: if not content:
@ -3815,6 +4056,10 @@ class MemoryCompanionService:
async def tool_recall(self, event: Any, query: str, top_k: int = 5) -> dict[str, Any]: async def tool_recall(self, event: Any, query: str, top_k: int = 5) -> dict[str, Any]:
ctx = await self.identity.resolve_event_context(event) ctx = await self.identity.resolve_event_context(event)
state = self._p3_prepare_context(ctx, event=event)
reason = self._p3_gate_reason(ctx, event=event, state=state)
if reason:
return {"ok": False, "error": reason, "memories": []}
query = clean_text(query, 1000) query = clean_text(query, 1000)
if not query: if not query:
return {"ok": False, "error": "empty query", "memories": []} return {"ok": False, "error": "empty query", "memories": []}
@ -4867,7 +5112,13 @@ class MemoryCompanionService:
) )
return injection return injection
async def inject_memories(self, ctx: SessionContext, req: Any, *, event: Any = None) -> None: async def inject_memories(self, ctx: SessionContext, req: Any, *, event: Any = None) -> str | None:
state = self._p3_prepare_context(ctx, event=event, req=req)
reason = self._p3_gate_reason(ctx, event=event, req=req, state=state)
if reason:
remove_temp_text(req, MEMORY_COMPANION_INJECTION_HEADER, MEMORY_COMPANION_INJECTION_FOOTER)
self._mark_memory_companion_injection_state(event, req, injected=False, conversation_memory=False, slot_map={})
return None
removed = remove_temp_text(req, MEMORY_COMPANION_INJECTION_HEADER, MEMORY_COMPANION_INJECTION_FOOTER) removed = remove_temp_text(req, MEMORY_COMPANION_INJECTION_HEADER, MEMORY_COMPANION_INJECTION_FOOTER)
if removed: if removed:
logger.info("[MemoryCompanion] 已清理历史记忆包注入片段: session=%s count=%s", ctx.session_id, removed) logger.info("[MemoryCompanion] 已清理历史记忆包注入片段: session=%s count=%s", ctx.session_id, removed)
@ -4875,7 +5126,7 @@ class MemoryCompanionService:
self._mark_memory_companion_injection_state(event, req, injected=False, conversation_memory=False, slot_map={}) self._mark_memory_companion_injection_state(event, req, injected=False, conversation_memory=False, slot_map={})
if self.config.bool("memory_injection.debug_log_injection_enabled", False): if self.config.bool("memory_injection.debug_log_injection_enabled", False):
logger.info("[MemoryCompanion] 记忆注入已关闭: session=%s", ctx.session_id) logger.info("[MemoryCompanion] 记忆注入已关闭: session=%s", ctx.session_id)
return return ""
self._sanitize_request_history_for_companion(ctx, req) self._sanitize_request_history_for_companion(ctx, req)
recent_fact_context = await self._recent_fact_guard_context(ctx) recent_fact_context = await self._recent_fact_guard_context(ctx)
recent_cross_window_context = await self._recent_cross_window_context(ctx) recent_cross_window_context = await self._recent_cross_window_context(ctx)
@ -4997,10 +5248,10 @@ class MemoryCompanionService:
slot_map={}, slot_map={},
) )
if append_temp_text(req, injection): if append_temp_text(req, injection):
return return injection
prompt = clean_text(getattr(req, "prompt", "") or "", 8000) prompt = clean_text(getattr(req, "prompt", "") or "", 8000)
req.prompt = f"{prompt}\n\n{injection}" if prompt else injection req.prompt = f"{prompt}\n\n{injection}" if prompt else injection
return return injection
blocked: list[dict[str, Any]] = [] blocked: list[dict[str, Any]] = []
retrieval_path_info: dict[str, Any] = { retrieval_path_info: dict[str, Any] = {
"mode": clean_text(self.config.get("retrieval.mode", "auto"), 40), "mode": clean_text(self.config.get("retrieval.mode", "auto"), 40),
@ -5153,7 +5404,7 @@ class MemoryCompanionService:
) )
if not injection: if not injection:
self._mark_memory_companion_injection_state(event, req, injected=False, conversation_memory=False, slot_map=slot_map) self._mark_memory_companion_injection_state(event, req, injected=False, conversation_memory=False, slot_map=slot_map)
return return ""
self._mark_memory_companion_injection_state( self._mark_memory_companion_injection_state(
event, event,
@ -5170,12 +5421,13 @@ class MemoryCompanionService:
len(results), len(results),
len(injection), len(injection),
) )
return return injection
prompt = clean_text(getattr(req, "prompt", "") or "", 8000) prompt = clean_text(getattr(req, "prompt", "") or "", 8000)
req.prompt = f"{prompt}\n\n{injection}" if prompt else injection req.prompt = f"{prompt}\n\n{injection}" if prompt else injection
logger.warning("[MemoryCompanion] TextPart 不可用,已回退到 prompt 注入: session=%s", ctx.session_id) logger.warning("[MemoryCompanion] TextPart 不可用,已回退到 prompt 注入: session=%s", ctx.session_id)
return injection
def _log_injection_debug( def _log_injection_debug(
self, self,
*, *,
@ -7779,6 +8031,8 @@ class MemoryCompanionService:
if isinstance(session_context, SessionContext): if isinstance(session_context, SessionContext):
return self._normalized_session_context(session_context) return self._normalized_session_context(session_context)
payload = session_context or {} payload = session_context or {}
p3_raw = payload.get("context_orchestration")
p3_state = consume_context_state(p3_raw) if p3_raw is not None else None
normalized = normalize_session_context_fields( normalized = normalize_session_context_fields(
session_id=str(payload.get("session_id") or ""), session_id=str(payload.get("session_id") or ""),
scope=str(payload.get("scope") or "unknown"), scope=str(payload.get("scope") or "unknown"),
@ -7800,6 +8054,9 @@ class MemoryCompanionService:
strict_session_only=bool(payload.get("strict_session_only", False)), strict_session_only=bool(payload.get("strict_session_only", False)),
preferred_address=str(payload.get("preferred_address") or ""), preferred_address=str(payload.get("preferred_address") or ""),
preferred_address_locked=bool(payload.get("preferred_address_locked", False)), preferred_address_locked=bool(payload.get("preferred_address_locked", False)),
context_orchestration=project_context_state(p3_state) or {},
context_orchestration_status=("accepted" if p3_state and p3_state.get("phase") != "invalid" else ("invalid" if p3_raw is not None else "unavailable")),
context_orchestration_error=("invalid_context_orchestration" if p3_raw is not None and (not p3_state or p3_state.get("phase") == "invalid") else ""),
) )
from .unified_person_contract import consume_unified_person_projection from .unified_person_contract import consume_unified_person_projection
resolved = consume_unified_person_projection( resolved = consume_unified_person_projection(
@ -7819,7 +8076,7 @@ class MemoryCompanionService:
user_id=ctx.user_id, user_id=ctx.user_id,
group_id=ctx.group_id, group_id=ctx.group_id,
) )
return SessionContext( result = SessionContext(
session_id=normalized["session_id"], session_id=normalized["session_id"],
scope=normalized["scope"], scope=normalized["scope"],
platform=normalized["platform"], platform=normalized["platform"],
@ -7836,7 +8093,13 @@ class MemoryCompanionService:
person_id=ctx.person_id, person_id=ctx.person_id,
person_origin_identity_key=ctx.person_origin_identity_key, person_origin_identity_key=ctx.person_origin_identity_key,
person_identity_assurance=ctx.person_identity_assurance, person_identity_assurance=ctx.person_identity_assurance,
context_orchestration=deepcopy(ctx.context_orchestration),
context_orchestration_status=ctx.context_orchestration_status,
context_orchestration_error=ctx.context_orchestration_error,
) )
if self._p3_take_trusted_legacy_context(ctx):
self._p3_mark_trusted_legacy_context(result)
return result
def stable_id(self, *parts: Any) -> str: def stable_id(self, *parts: Any) -> str:
raw = "|".join(clean_text(part, 500) for part in parts if part is not None) raw = "|".join(clean_text(part, 500) for part in parts if part is not None)

查看文件

@ -11,6 +11,7 @@ from astrbot.api.provider import LLMResponse, ProviderRequest
from astrbot.api.star import Context, Star, StarTools, register from astrbot.api.star import Context, Star, StarTools, register
from .core.bridge import MemoryCompanionBridge from .core.bridge import MemoryCompanionBridge
from .core.context_orchestration import MEMORY_CONTEXT as HOOK_PRIORITY_MEMORY_CONTEXT
from .core.commands import MemoryCompanionCommandHandler from .core.commands import MemoryCompanionCommandHandler
from .core.models import json_dumps from .core.models import json_dumps
from .core.service import MemoryCompanionService from .core.service import MemoryCompanionService
@ -85,7 +86,7 @@ class MemoryCompanionPlugin(Star):
self.page_api = None self.page_api = None
logger.warning("[MemoryCompanion] 拓展页 API 注册失败: %s", exc, exc_info=True) logger.warning("[MemoryCompanion] 拓展页 API 注册失败: %s", exc, exc_info=True)
@filter.on_llm_request(priority=-20) @filter.on_llm_request(priority=HOOK_PRIORITY_MEMORY_CONTEXT)
async def on_llm_request(self, event: AstrMessageEvent, req: ProviderRequest): async def on_llm_request(self, event: AstrMessageEvent, req: ProviderRequest):
await self.service.handle_llm_request(event, req) await self.service.handle_llm_request(event, req)

查看文件

@ -0,0 +1 @@
{"contract_name":"ops.context_orchestration.v1","contract_version":"1.0","attribute_name":"_ops_context_orchestration_v1","fixture_version":"1","layers":["persona","runtime","person","scene","memory","safety"],"phases":["initialized","companion_ready","memory_ready","safety_ready","finalized","invalid"],"security_statuses":["allowed","sanitized","blocked","quarantined","unavailable"],"policies":["inherit","allow","deny","quarantine"],"trust_levels":["T0","T1","T2","T3","T4"],"state_fields":["contract_name","contract_version","contract_fingerprint","request_id","session_id","scope","created_at","phase","completed_layers","fragments","security","errors","finalized"],"security_fields":["status","event_id","memory_policy","tool_policy","response_policy","reason_codes"],"fragment_fields":["key","layer","source","trust_level","content_hash","chars","status"],"limits":{"fragments":64,"errors":16,"reason_codes":16}}

查看文件

@ -0,0 +1,268 @@
from __future__ import annotations
import asyncio
import hashlib
import json
import unittest
from pathlib import Path
from types import SimpleNamespace
from core import context_orchestration as contract
from core.bridge import MemoryCompanionBridge
from core.models import SessionContext
from core.service import MemoryCompanionService
def ready_state() -> dict:
state = contract.new_context_state(request_id="r", session_id="private:a", scope="private")
for layer in ("persona", "runtime", "person", "scene"):
contract.complete_layer(state, layer)
return state
class _Identity:
def __init__(self, ctx: SessionContext):
self.ctx = ctx
async def resolve_event_context(self, event):
return self.ctx
class _Config:
def bool(self, key, default=False):
return True
class _GateService(MemoryCompanionService):
def __init__(self, ctx: SessionContext):
self.identity = _Identity(ctx)
self.config = _Config()
self.reached_write_path = False
def _sanitize_session_context_message_text(self, ctx):
return None
def _apply_private_companion_preferred_address(self, ctx, **kwargs):
return None
def _private_companion_internal_generation_event(self, event):
return False
def _mark_memory_companion_injection_state(self, *args, **kwargs):
return None
async def note_identity(self, ctx):
self.reached_write_path = True
class _BridgeProbe:
def __init__(self, service: MemoryCompanionService):
self.service = service
self.received: SessionContext | None = None
self.gate_reason = ""
def session_context_from_bridge(self, payload):
return self.service.session_context_from_bridge(payload)
def _p3_mark_trusted_legacy_context(self, ctx):
self.service._p3_mark_trusted_legacy_context(ctx)
async def bridge_search(self, query, *, session_context=None, top_k=None):
self.received = self.service.session_context_from_bridge(session_context)
self.gate_reason = self.service._p3_bridge_gate_reason(self.received)
return ["same-session"] if not self.gate_reason else []
class P3MemoryTests(unittest.TestCase):
def setUp(self) -> None:
self.service = MemoryCompanionService.__new__(MemoryCompanionService)
def test_fixture_descriptor_and_fingerprint(self):
fixture = json.loads((Path(__file__).parent / "fixtures" / "context_orchestration_v1.json").read_text(encoding="utf-8"))
descriptor = contract.contract_descriptor()
self.assertEqual(fixture, descriptor)
self.assertEqual(len(contract.contract_fingerprint()), 64)
self.assertEqual(contract.MEMORY_CONTEXT, -20)
def test_created_at_is_valid_projected_and_immutable(self):
fixed = "2026-07-29T00:00:00.000Z"
state = contract.new_context_state(created_at=fixed)
contract.complete_layer(state, "persona")
self.assertEqual(state["created_at"], fixed)
self.assertEqual(contract.project_context_state(state)["created_at"], fixed)
invalid = contract.project_context_state(state) or {}
invalid["created_at"] = ""
self.assertEqual(contract.consume_context_state(invalid)["phase"], "invalid")
def test_contract_rejects_unknown_fields_limits_order_and_finalized_mismatch(self):
unknown = ready_state()
unknown["raw_content"] = "must not cross the contract"
self.assertEqual(contract.consume_context_state(unknown)["phase"], "invalid")
too_many_errors = ready_state()
too_many_errors["errors"] = ["x"] * 17
self.assertEqual(contract.consume_context_state(too_many_errors)["phase"], "invalid")
finalized_mismatch = ready_state()
finalized_mismatch["phase"] = "finalized"
self.assertEqual(contract.consume_context_state(finalized_mismatch)["phase"], "invalid")
wrong_order = contract.new_context_state()
wrong_order["completed_layers"] = ["scene", "persona"]
self.assertEqual(contract.consume_context_state(wrong_order)["phase"], "invalid")
canonical = contract.new_context_state()
contract.complete_layer(canonical, "scene")
contract.complete_layer(canonical, "persona")
self.assertEqual(canonical["completed_layers"], ["persona", "scene"])
def test_controlled_codes_reject_untrusted_values_without_coercion(self):
accepted = contract.new_context_state()
contract.update_security(accepted, reason_codes="a" * 120)
self.assertEqual(accepted["security"]["reason_codes"], ["a" * 120])
for value in ("", "a" * 121, "bad code", "bad\ncode", 7):
state = contract.new_context_state()
contract.update_security(state, reason_codes=[value])
self.assertEqual(state["phase"], "invalid")
self.assertIn("reason_code_invalid", state["errors"])
malformed = contract.new_context_state()
malformed["security"]["reason_codes"] = ["raw prose"]
self.assertEqual(contract.consume_context_state(malformed)["phase"], "invalid")
def test_gate_security_and_person_completion(self):
ctx = SessionContext(session_id="private:a", scope="private", person_id="person:a")
self.assertEqual(self.service._p3_gate_reason(ctx, state=None, high_risk=True), "p3_unavailable")
state = contract.new_context_state(session_id=ctx.session_id, scope=ctx.scope)
self.assertEqual(self.service._p3_gate_reason(ctx, state=state, high_risk=True), "p3_core_incomplete")
for layer in ("persona", "runtime", "person", "scene"):
contract.complete_layer(state, layer)
self.assertEqual(self.service._p3_gate_reason(ctx, state=state, high_risk=True), "")
for status in ("blocked", "quarantined", "unavailable"):
blocked = ready_state(); contract.update_security(blocked, status=status)
self.assertEqual(self.service._p3_gate_reason(ctx, state=blocked, high_risk=True), f"p3_security_{status}")
denied = ready_state(); contract.update_security(denied, memory_policy="deny")
self.assertEqual(self.service._p3_gate_reason(ctx, state=denied, high_risk=True), "p3_memory_policy_deny")
def test_memory_outcome_is_metadata_only_and_idempotent(self):
state = ready_state()
ctx = SessionContext(session_id="private:a", scope="private")
req, event = SimpleNamespace(), SimpleNamespace()
injection = "actual memory injection"
self.service._p3_complete_memory(state, ctx=ctx, injection=injection, event=event, req=req)
self.service._p3_complete_memory(state, ctx=ctx, injection=injection, event=event, req=req)
self.assertEqual(state["phase"], "memory_ready")
memory_fragments = [item for item in state["fragments"] if item["layer"] == "memory"]
self.assertEqual(len(memory_fragments), 1)
self.assertNotIn("content", memory_fragments[0])
self.assertEqual(memory_fragments[0]["chars"], len(injection))
self.assertEqual(memory_fragments[0]["content_hash"], hashlib.sha256(injection.encode("utf-8")).hexdigest())
self.assertIs(contract.read_context_state(req, event), state)
def test_bridge_context_consumes_bad_contract_and_strict_flag_cannot_forge_person(self):
bad = ready_state(); bad["contract_version"] = "bad"
ctx = self.service.session_context_from_bridge({
"session_id": "private:a", "scope": "private", "strict_session_only": True,
"context_orchestration": bad,
})
self.assertEqual(ctx.context_orchestration_status, "invalid")
person_ctx = SessionContext(session_id="private:a", scope="private", strict_session_only=True, person_id="person:a")
self.assertEqual(self.service._p3_gate_reason(person_ctx, state=None), "p3_unavailable")
def test_bridge_gate_limits_legacy_to_same_session_and_requires_companion_ready(self):
legacy = self.service.session_context_from_bridge({
"session_id": "private:a", "scope": "private", "strict_session_only": False,
})
self.assertEqual(legacy.context_orchestration_status, "unavailable")
self.assertEqual(self.service._p3_bridge_gate_reason(legacy), "p3_unavailable")
person = SessionContext(session_id="private:a", scope="private", person_id="person:a")
self.assertEqual(self.service._p3_bridge_gate_reason(person), "p3_unavailable")
forged = SessionContext(
session_id="private:a", scope="private", context_orchestration_status="legacy_local",
)
self.assertEqual(self.service._p3_bridge_gate_reason(forged), "p3_unavailable")
state = ready_state()
accepted = SessionContext(
session_id="private:a", scope="private",
context_orchestration=contract.project_context_state(state) or {},
context_orchestration_status="accepted",
)
self.assertEqual(self.service._p3_bridge_gate_reason(accepted), "")
contract.complete_layer(state, "memory")
accepted.context_orchestration = contract.project_context_state(state) or {}
self.assertEqual(self.service._p3_bridge_gate_reason(accepted), "p3_phase_not_companion_ready")
def test_public_bridge_mints_legacy_only_for_low_risk_valid_session(self):
probe = _BridgeProbe(self.service)
bridge = MemoryCompanionBridge(probe)
result = asyncio.run(bridge.search(
"hello", session_context={"session_id": "private:a", "scope": "private"},
))
self.assertEqual(result, ["same-session"])
self.assertEqual(probe.gate_reason, "")
self.assertIsNotNone(probe.received)
self.assertEqual(probe.received.context_orchestration_status, "legacy_local")
self.assertTrue(probe.received.strict_session_only)
self.assertEqual(getattr(self.service, "_p3_trusted_legacy_contexts", {}), {})
rejected = asyncio.run(bridge.search(
"hello",
session_context={
"session_id": "private:a", "scope": "private",
"unified_person_projection": {"person_id": "person:a"},
},
))
self.assertEqual(rejected, [])
self.assertEqual(probe.gate_reason, "p3_unavailable")
bad = ready_state(); bad["contract_version"] = "bad"
rejected = asyncio.run(bridge.search(
"hello",
session_context={"session_id": "private:a", "scope": "private", "context_orchestration": bad},
))
self.assertEqual(rejected, [])
self.assertEqual(probe.gate_reason, "p3_invalid")
def test_archive_requires_contract(self):
result = asyncio.run(self.service.bridge_search_archive_memories(
"x", scope={"session_id": "private:a", "scope": "private", "user_id": "a"}, limit=1,
))
self.assertEqual(result["memories"], [])
self.assertIn("p3_unavailable", result["warnings"])
self.service.config = _Config()
create = asyncio.run(self.service.bridge_create_archive_memory(
scope={"session_id": "private:a", "scope": "private", "user_id": "a"},
content="archive", metadata={}, confirmed_by="owner", operation_id="op-1",
))
self.assertEqual(create["error"], "p3_unavailable")
self.assertEqual(create["memory_id"], "")
def test_blocked_request_group_response_and_external_write_stop_before_storage(self):
state = ready_state(); contract.update_security(state, status="blocked")
event = SimpleNamespace()
req = SimpleNamespace(system_prompt="", prompt="")
contract.attach_context_state(state, req, event)
service = _GateService(SessionContext(session_id="private:a", scope="private", message_text="hello"))
asyncio.run(service.handle_llm_request(event, req))
self.assertFalse(service.reached_write_path)
self.assertEqual(state["security"]["memory_policy"], "deny")
group_state = ready_state(); contract.update_security(group_state, status="quarantined")
group_event = SimpleNamespace(); contract.attach_context_state(group_state, event=group_event)
group_service = _GateService(SessionContext(session_id="group:g", scope="group", group_id="g", user_id="u", message_text="hello"))
asyncio.run(group_service.handle_group_message(group_event))
self.assertFalse(group_service.reached_write_path)
response_state = ready_state(); contract.update_security(response_state, status="unavailable")
response_event = SimpleNamespace(); contract.attach_context_state(response_state, event=response_event)
response_service = _GateService(SessionContext(session_id="private:a", scope="private", message_text="hello"))
asyncio.run(response_service.handle_llm_response(response_event, SimpleNamespace(role="assistant", completion_text="reply")))
self.assertFalse(response_service.reached_write_path)
external = MemoryCompanionService.__new__(MemoryCompanionService)
external.config = _Config()
with self.assertRaises(Exception):
asyncio.run(external.record_external_event(
content="blocked", memory_type="user_fact", memory_domain="user_memory",
scope="private", session_id="private:a",
metadata={"context_orchestration": response_state},
))
if __name__ == "__main__":
unittest.main()

查看文件

@ -0,0 +1,154 @@
from __future__ import annotations
import json
from dataclasses import fields
from pathlib import Path
from core import context_orchestration
from core.bridge import MemoryCompanionBridge
from core.models import MemoryRecord, SessionContext
from core.service import MemoryCompanionService
from core.store import MemoryStore
FIXTURE_PATH = Path(__file__).parent / "fixtures" / "unified_person_projection_v1.json"
SOURCE_IDENTITY = {
"companion_instance_id": "companion-a",
"bot_account_id": "bot-1",
"adapter_instance_id": "telegram-main",
"subject_namespace": "telegram.user",
"platform_subject_id": "42",
}
# These fields belong to P4's companion-owned affinity/confinement state
# machine. A memory-side transport object or persistence schema must not
# acquire them as authority-bearing state.
P4_STATE_FIELDS = frozenset(
{
"affinity_score",
"affinity_band",
"warning_stage",
"confinement_state",
"confinement_until",
"confinement_round",
"release_prompt_pending",
"affinity_event_id",
"violation_event_id",
}
)
P4_AUTHORITY_TERMS = ("affinity", "confinement", "warning", "release", "settle", "recompute")
def _projection() -> dict:
return json.loads(FIXTURE_PATH.read_text(encoding="utf-8"))
def _service() -> MemoryCompanionService:
return MemoryCompanionService.__new__(MemoryCompanionService)
def _ready_p3_state() -> dict:
state = context_orchestration.new_context_state(session_id="private:42", scope="private")
for layer in ("persona", "runtime", "person", "scene"):
context_orchestration.complete_layer(state, layer)
return state
def test_bridge_reduces_verified_projection_to_identity_only_session_context():
bridge = MemoryCompanionBridge(_service())
context = bridge._trusted_session_context(
{
"session_id": "private:42",
"scope": "private",
"unified_person_projection": _projection(),
"unified_person_source_identity": SOURCE_IDENTITY,
}
)
assert isinstance(context, SessionContext)
assert context.person_id == "person_d301001be7a1ce40df26a3eb"
assert context.person_origin_identity_key == _projection()["resolved_identity_key"]
assert context.person_identity_assurance == "verified"
assert context.context_orchestration == {}
assert context.context_orchestration_status == "unavailable"
session_fields = {item.name for item in fields(SessionContext)}
memory_fields = {item.name for item in fields(MemoryRecord)}
assert P4_STATE_FIELDS.isdisjoint(session_fields)
assert P4_STATE_FIELDS.isdisjoint(memory_fields)
assert all(not hasattr(context, field) for field in P4_STATE_FIELDS)
def test_public_memory_bridge_exposes_no_p4_authority_operation():
public_operations = {
name
for name in dir(MemoryCompanionBridge)
if not name.startswith("_") and callable(getattr(MemoryCompanionBridge, name))
}
authority_operations = {
name
for name in public_operations
if any(term in name.lower() for term in P4_AUTHORITY_TERMS)
}
assert authority_operations == set()
def test_memory_schema_has_no_p4_affinity_or_confinement_authority(tmp_path):
store = MemoryStore(tmp_path / "memory.db")
store.initialize()
try:
table_names = {
str(row["name"])
for row in store._conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()
}
p4_tables = {
name
for name in table_names
if any(term in name.lower() for term in ("affinity", "confinement", "release"))
}
schema_columns: set[str] = set()
for table_name in table_names:
quoted_name = table_name.replace('"', '""')
schema_columns.update(
str(row["name"])
for row in store._conn.execute(f'PRAGMA table_info("{quoted_name}")').fetchall()
)
assert p4_tables == set()
assert P4_STATE_FIELDS.isdisjoint(schema_columns)
finally:
store.close()
def test_p4_shaped_inputs_fail_closed_at_p2_and_p3_boundaries():
service = _service()
invalid_projection = _projection()
invalid_projection["affinity_score"] = -1201
invalid_projection["affinity_band"] = "critical"
p2_context = service.session_context_from_bridge(
{
"session_id": "private:42",
"scope": "private",
"unified_person_projection": invalid_projection,
"unified_person_source_identity": SOURCE_IDENTITY,
}
)
assert p2_context.person_id == ""
assert p2_context.person_origin_identity_key == ""
assert p2_context.person_identity_assurance == ""
p3_state = _ready_p3_state()
p3_state["release_prompt_pending"] = True
p3_context = service.session_context_from_bridge(
{
"session_id": "private:42",
"scope": "private",
"context_orchestration": p3_state,
}
)
assert p3_context.context_orchestration_status == "invalid"
assert p3_context.context_orchestration["phase"] == "invalid"
assert "release_prompt_pending" not in p3_context.context_orchestration
assert service._p3_bridge_gate_reason(p3_context) == "p3_invalid"

查看文件

@ -13,6 +13,7 @@ ROOT = Path(__file__).resolve().parents[1]
if str(ROOT.parent) not in sys.path: if str(ROOT.parent) not in sys.path:
sys.path.insert(0, str(ROOT.parent)) sys.path.insert(0, str(ROOT.parent))
from core import context_orchestration as p3_contract
from core.bridge import MemoryCompanionBridge from core.bridge import MemoryCompanionBridge
from core.models import EntityRef, MemoryRecord, SearchResult, SessionContext from core.models import EntityRef, MemoryRecord, SearchResult, SessionContext
from core.service import MemoryCompanionService from core.service import MemoryCompanionService
@ -164,9 +165,13 @@ class SummaryAndRelationshipTests(unittest.IsolatedAsyncioTestCase):
raise AssertionError("generic retrieval engine must not run for schedule_fast") raise AssertionError("generic retrieval engine must not run for schedule_fast")
service._retrieval_engine = fail_if_called service._retrieval_engine = fail_if_called
text = await service.bridge_compose_context( bridge = MemoryCompanionBridge(service)
text = await bridge.compose_context(
query=ctx.message_text, query=ctx.message_text,
session_context=ctx, session_context={
"session_id": ctx.session_id, "scope": ctx.scope, "user_id": ctx.user_id,
"bot_id": ctx.bot_id, "message_text": ctx.message_text,
},
top_k=5, top_k=5,
max_chars=1200, max_chars=1200,
retrieval_profile="schedule_fast", retrieval_profile="schedule_fast",
@ -367,9 +372,13 @@ class SummaryAndRelationshipTests(unittest.IsolatedAsyncioTestCase):
max_chars=1800, max_chars=1800,
recent_fact_context=recent_context, recent_fact_context=recent_context,
) )
bridged = await service.bridge_compose_injection( bridge = MemoryCompanionBridge(service)
bridged = await bridge.compose_injection(
"不是这样", "不是这样",
session_context=ctx, session_context={
"session_id": ctx.session_id, "scope": ctx.scope, "user_id": ctx.user_id,
"bot_id": ctx.bot_id, "message_text": ctx.message_text,
},
max_chars=1800, max_chars=1800,
) )
@ -497,6 +506,11 @@ class SummaryAndRelationshipTests(unittest.IsolatedAsyncioTestCase):
user_id="u1", user_id="u1",
message_text="今日穿搭、历史穿搭、服装偏好和最近自拍", message_text="今日穿搭、历史穿搭、服装偏好和最近自拍",
) )
p3_state = p3_contract.new_context_state(session_id=ctx.session_id, scope=ctx.scope)
for layer in ("persona", "runtime", "person", "scene"):
p3_contract.complete_layer(p3_state, layer)
ctx.context_orchestration = p3_contract.project_context_state(p3_state) or {}
ctx.context_orchestration_status = "accepted"
records = [ records = [
MemoryRecord( MemoryRecord(
id="outfit-schedule", id="outfit-schedule",