Add memory system session context API

memory_system_api/service.py

@@ -15,6 +15,8 @@ from .schemas import (
     ProfileResponse,
     SearchRequest,
     SearchResponse,
+    SessionContextRequest,
+    SessionContextResponse,
 )
 
 
@@ -124,6 +126,40 @@ class MemorySystemService:
             backends=compact_backends,
         )
 
+    async def get_session_context(self, session_id: str, request: SessionContextRequest) -> SessionContextResponse:
+        credential = self.openviking.credential_for_user(
+            request.user_id,
+            request.user_key,
+            agent_id=session_id,
+        )
+
+        async def read_openviking_context() -> dict[str, Any]:
+            return await self.openviking.get_session_context(credential, session_id)
+
+        async def search_everos() -> dict[str, Any]:
+            return await self.everos.search(
+                request.user_id,
+                session_id,
+                request.query,
+                "hybrid",
+                request.limit,
+            )
+
+        backends = await self._run_backends(openviking=read_openviking_context, everos=search_everos)
+        backends = self._remove_vectors_from_backends(backends)
+        context = self._context_from_openviking_result(backends["openviking"].result)
+        items = (
+            self._items_from_backend_result("everos", backends["everos"].result)[: request.limit]
+            if backends["everos"].status == "success"
+            else []
+        )
+        return SessionContextResponse(
+            status=self._aggregate_status(backends),
+            context=context,
+            items=items,
+            backends=self._compact_session_context_backends(backends),
+        )
+
     async def get_profile(self, user_id: str) -> ProfileResponse:
         backends = {"everos": await self._capture(lambda: self.everos.get_profile(user_id))}
         profile = backends["everos"].result if backends["everos"].status == "success" else None
@@ -260,6 +296,33 @@ class MemorySystemService:
 
         return result
 
+    def _context_from_openviking_result(self, result: Any) -> dict[str, Any] | None:
+        if not isinstance(result, dict):
+            return None
+        data = result.get("result") if isinstance(result.get("result"), dict) else result
+        return data if isinstance(data, dict) else None
+
+    def _compact_session_context_backends(self, backends: dict[str, BackendStatus]) -> dict[str, BackendStatus]:
+        return {
+            name: backend.model_copy(update={"result": self._compact_session_context_backend_result(name, backend.result)})
+            for name, backend in backends.items()
+        }
+
+    def _compact_session_context_backend_result(self, backend_name: str, result: Any) -> Any:
+        if backend_name == "openviking":
+            data = self._context_from_openviking_result(result)
+            if data is None:
+                return result
+            compact = {
+                "status": result.get("status") if isinstance(result, dict) else None,
+                "estimatedTokens": data.get("estimatedTokens"),
+                "stats": data.get("stats"),
+                "has_latest_archive_overview": bool(data.get("latest_archive_overview")),
+                "message_count": len(data.get("messages") or []) if isinstance(data.get("messages"), list) else 0,
+            }
+            return {key: value for key, value in compact.items() if value is not None}
+        return self._compact_backend_result(backend_name, result)
+
     def _remove_vectors_from_backends(self, backends: dict[str, BackendStatus]) -> dict[str, BackendStatus]:
         return {
             name: backend.model_copy(update={"result": self._remove_vectors(backend.result)})