- Demo accounts: super_admin-only provisioning into isolated DEMO_ORG_ID tenant, 30-day UTC trial on first login, revocable, one-time credential delivery via optional SES/webhook (never persisted). Adds boto3 dependency. - Analytics/report/export/privacy: shared bounded scan budget across users/groups/ sessions, tenant-consistent session/user/group joins, scalar-only CSV export (no nested persisted-value stringification). - Ownership/tenant isolation: canonical owner-tenant predicate for list/read/chat; client sees is_owned only, never owner_user_id. - Lifecycle/races: status transition validation, analyzing is an in-progress gate (no duplicate reanalysis), structured-ready publication, stale-variant revalidation. - Auth/setup/consent/JWT/OAuth/config: fail-closed consent, bounded JWT lifetime, provider-subject atomic OAuth identity, repeated-secret rejection, strict Persona trait validation. - Chat/session/privacy: pre-seller opener redaction, corrupt-session recovery, role-aware completed-chat dashboard routing. - Frontend: Training→product→personas→practice flow, demo/role/demo guards, is_owned-based ownership display, 320×568 and 500×768 responsive E2E. - 8 independent exact-five-key review scopes passed; backend 509, frontend 26, production build 1775 modules, isolated E2E 15.
279 lines
9.1 KiB
Python
279 lines
9.1 KiB
Python
"""Training session store.
|
|
|
|
A session is identified by the full tenant scope ``(org, user, group, persona)``
|
|
plus its mode. A trainee session is one-shot; preview sessions are deliberately
|
|
outside that invariant so instructors can test a persona without consuming a
|
|
trainee attempt. The scope scan and create happen under one collection lock so
|
|
two worker threads/processes cannot create competing active sessions.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import datetime
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
from ..storage.store import JsonStore, new_id
|
|
|
|
|
|
def _now() -> str:
|
|
return datetime.datetime.now(datetime.timezone.utc).isoformat()
|
|
|
|
|
|
class SessionStore:
|
|
def __init__(self, data_dir: Path) -> None:
|
|
self.sessions = JsonStore(data_dir / "sessions")
|
|
|
|
def create(
|
|
self,
|
|
*,
|
|
org_id: str,
|
|
user_id: str,
|
|
group_id: str,
|
|
persona_id: str,
|
|
persona_name: str,
|
|
persona_meta: dict[str, Any] | None = None,
|
|
mode: str = "trainee",
|
|
messages: list[dict[str, Any]] | None = None,
|
|
internal: dict[str, Any] | None = None,
|
|
scenario: str | None = None,
|
|
locale: str | None = None,
|
|
) -> dict[str, Any]:
|
|
self._validate_scope(org_id, user_id, group_id, persona_id, mode)
|
|
sid = new_id("session")
|
|
session = {
|
|
"id": sid,
|
|
"org_id": org_id,
|
|
"user_id": user_id,
|
|
"group_id": group_id,
|
|
"persona_id": persona_id,
|
|
"persona_name": persona_name,
|
|
"persona_meta": persona_meta or {},
|
|
"scenario": scenario,
|
|
"locale": locale,
|
|
"mode": mode,
|
|
"status": "active", # active | finished
|
|
"outcome": None, # won | lost | abandoned
|
|
"messages": list(messages or []), # [{role, text, ts}]
|
|
"internal": dict(internal or {"trust": 50, "pain_progress": {}, "buying_signals": [], "tier": None}),
|
|
"debrief": None,
|
|
"created_at": _now(),
|
|
"updated_at": _now(),
|
|
}
|
|
return self.sessions.create(session, key=sid)
|
|
|
|
@staticmethod
|
|
def _validate_scope(
|
|
org_id: str,
|
|
user_id: str,
|
|
group_id: str,
|
|
persona_id: str,
|
|
mode: str,
|
|
) -> None:
|
|
if not all(isinstance(value, str) and value.strip() for value in (
|
|
org_id, user_id, group_id, persona_id,
|
|
)):
|
|
raise ValueError("session scope is invalid")
|
|
if mode not in ("trainee", "preview"):
|
|
raise ValueError("session mode is invalid")
|
|
|
|
@staticmethod
|
|
def _mode(row: dict[str, Any]) -> str:
|
|
# Records created before the explicit mode field are normal trainee attempts.
|
|
mode = row.get("mode")
|
|
if mode is None:
|
|
return "trainee"
|
|
return mode if isinstance(mode, str) else ""
|
|
|
|
|
|
def _raw_scope_rows(
|
|
self,
|
|
*,
|
|
org_id: str,
|
|
user_id: str,
|
|
group_id: str,
|
|
persona_id: str,
|
|
) -> list[dict[str, Any]]:
|
|
return self.sessions.where(
|
|
lambda row: isinstance(row, dict)
|
|
and row.get("org_id") == org_id
|
|
and row.get("user_id") == user_id
|
|
and row.get("group_id") == group_id
|
|
and row.get("persona_id") == persona_id
|
|
)
|
|
|
|
def _scope_rows(
|
|
self,
|
|
*,
|
|
org_id: str,
|
|
user_id: str,
|
|
group_id: str,
|
|
persona_id: str,
|
|
mode: str,
|
|
) -> list[dict[str, Any]]:
|
|
return [
|
|
row
|
|
for row in self._raw_scope_rows(
|
|
org_id=org_id,
|
|
user_id=user_id,
|
|
group_id=group_id,
|
|
persona_id=persona_id,
|
|
)
|
|
if isinstance(row, dict) and self._mode(row) == mode
|
|
]
|
|
|
|
def start(
|
|
self,
|
|
*,
|
|
org_id: str,
|
|
user_id: str,
|
|
group_id: str,
|
|
persona_id: str,
|
|
persona_name: str,
|
|
persona_meta: dict[str, Any] | None = None,
|
|
mode: str = "trainee",
|
|
messages: list[dict[str, Any]] | None = None,
|
|
internal: dict[str, Any] | None = None,
|
|
scenario: str | None = None,
|
|
locale: str | None = None,
|
|
) -> tuple[dict[str, Any], bool]:
|
|
"""Atomically resume or create a session in one canonical scope.
|
|
|
|
Returns ``(session, resumed)``. Only trainee sessions enforce the
|
|
one-shot finished-session rule; preview sessions can be started again.
|
|
"""
|
|
self._validate_scope(org_id, user_id, group_id, persona_id, mode)
|
|
with self.sessions.collection_lock():
|
|
raw_rows = [
|
|
row
|
|
for row in self._raw_scope_rows(
|
|
org_id=org_id,
|
|
user_id=user_id,
|
|
group_id=group_id,
|
|
persona_id=persona_id,
|
|
)
|
|
if isinstance(row, dict)
|
|
]
|
|
for row in raw_rows:
|
|
row_mode = self._mode(row)
|
|
status = row.get("status")
|
|
outcome = row.get("outcome")
|
|
if (
|
|
row_mode not in ("trainee", "preview")
|
|
or status not in ("active", "finished")
|
|
or outcome not in (None, "won", "lost", "abandoned")
|
|
or (status == "active" and outcome is not None)
|
|
or (status == "finished" and outcome not in ("won", "lost", "abandoned"))
|
|
):
|
|
raise ValueError("invalid persisted session state")
|
|
rows = self._scope_rows(
|
|
org_id=org_id,
|
|
user_id=user_id,
|
|
group_id=group_id,
|
|
persona_id=persona_id,
|
|
mode=mode,
|
|
)
|
|
active = next((row for row in rows if row.get("status") == "active"), None)
|
|
if active is not None:
|
|
return active, True
|
|
if mode == "trainee" and any(
|
|
row.get("status") == "finished"
|
|
or row.get("outcome") in ("won", "lost", "abandoned")
|
|
for row in rows
|
|
):
|
|
raise ValueError("you have already trained on this persona (one-shot)")
|
|
return self.create(
|
|
org_id=org_id,
|
|
user_id=user_id,
|
|
group_id=group_id,
|
|
persona_id=persona_id,
|
|
persona_name=persona_name,
|
|
persona_meta=persona_meta,
|
|
mode=mode,
|
|
messages=messages,
|
|
internal=internal,
|
|
scenario=scenario,
|
|
locale=locale,
|
|
), False
|
|
|
|
def get(self, sid: str) -> dict[str, Any]:
|
|
return self.sessions.get(sid)
|
|
|
|
def get_or_none(self, sid: str) -> dict[str, Any] | None:
|
|
return self.sessions.get_or_none(sid)
|
|
|
|
def update(self, sid: str, **fields: Any) -> dict[str, Any]:
|
|
fields.setdefault("updated_at", _now())
|
|
return self.sessions.update(sid, **fields)
|
|
|
|
def mutation_lock(self, sid: str):
|
|
"""Serialize a full session transaction across threads and workers."""
|
|
return self.sessions.record_lock(sid)
|
|
|
|
def active_for_scope(
|
|
self,
|
|
*,
|
|
org_id: str,
|
|
user_id: str,
|
|
group_id: str,
|
|
persona_id: str,
|
|
mode: str = "trainee",
|
|
) -> dict[str, Any] | None:
|
|
self._validate_scope(org_id, user_id, group_id, persona_id, mode)
|
|
hits = [
|
|
row for row in self._scope_rows(
|
|
org_id=org_id,
|
|
user_id=user_id,
|
|
group_id=group_id,
|
|
persona_id=persona_id,
|
|
mode=mode,
|
|
)
|
|
if isinstance(row, dict) and row.get("status") == "active"
|
|
]
|
|
return hits[0] if hits else None
|
|
|
|
def latest_for_scope(
|
|
self,
|
|
*,
|
|
org_id: str,
|
|
user_id: str,
|
|
group_id: str,
|
|
persona_id: str,
|
|
mode: str = "trainee",
|
|
) -> dict[str, Any] | None:
|
|
"""Return the newest record in one scope, including finished sessions."""
|
|
self._validate_scope(org_id, user_id, group_id, persona_id, mode)
|
|
rows = [
|
|
row
|
|
for row in self._scope_rows(
|
|
org_id=org_id,
|
|
user_id=user_id,
|
|
group_id=group_id,
|
|
persona_id=persona_id,
|
|
mode=mode,
|
|
)
|
|
if isinstance(row, dict)
|
|
]
|
|
return max(rows, key=lambda row: row.get("updated_at", ""), default=None)
|
|
|
|
def list_for_user(
|
|
self,
|
|
user_id: str,
|
|
*,
|
|
org_id: str | None = None,
|
|
include_preview: bool = False,
|
|
) -> list[dict[str, Any]]:
|
|
rows = [
|
|
row
|
|
for row in self.sessions.where(
|
|
lambda row: isinstance(row, dict)
|
|
and row.get("user_id") == user_id
|
|
and (org_id is None or row.get("org_id") == org_id)
|
|
and (include_preview or self._mode(row) == "trainee")
|
|
)
|
|
if isinstance(row, dict)
|
|
]
|
|
return sorted(
|
|
rows,
|
|
key=lambda r: r.get("created_at", ""),
|
|
)
|