diff --git a/gateway/platforms/api_server.py b/gateway/platforms/api_server.py index 22bf199b3b069..05fe95d9a21ca 100644 --- a/gateway/platforms/api_server.py +++ b/gateway/platforms/api_server.py @@ -1137,6 +1137,7 @@ async def _handle_capabilities(self, request: "web.Request") -> "web.Response": "sessions": {"method": "GET", "path": "/api/sessions"}, "session_create": {"method": "POST", "path": "/api/sessions"}, "session": {"method": "GET", "path": "/api/sessions/{session_id}"}, + "session_prompt": {"method": "POST", "path": "/api/sessions/{session_id}/prompt"}, "session_update": {"method": "PATCH", "path": "/api/sessions/{session_id}"}, "session_delete": {"method": "DELETE", "path": "/api/sessions/{session_id}"}, "session_messages": {"method": "GET", "path": "/api/sessions/{session_id}/messages"}, @@ -1250,15 +1251,17 @@ def _parse_nonnegative_int(value: Any, default: int, maximum: int) -> int: @staticmethod def _session_response(session: Dict[str, Any]) -> Dict[str, Any]: """Return a stable, client-safe session representation.""" + from hermes_state import apply_session_live_work + viewed = apply_session_live_work(dict(session)) safe_keys = ( "id", "source", "user_id", "model", "title", "started_at", "ended_at", "end_reason", "message_count", "tool_call_count", "input_tokens", "output_tokens", "cache_read_tokens", "cache_write_tokens", "reasoning_tokens", "estimated_cost_usd", "actual_cost_usd", "api_call_count", "parent_session_id", "last_active", "preview", - "_lineage_root_id", + "_lineage_root_id", "live", "metadata", "owner", "profile", ) - payload = {key: session.get(key) for key in safe_keys if key in session} + payload = {key: viewed.get(key) for key in safe_keys if key in viewed} # Avoid exposing full system prompts/model_config through the client API; # callers only need to know whether those snapshots exist. payload["has_system_prompt"] = bool(session.get("system_prompt")) @@ -1406,6 +1409,40 @@ async def _handle_patch_session(self, request: "web.Request") -> "web.Response": session = db.get_session(session_id) or session return web.json_response({"object": "hermes.session", "session": self._session_response(session)}) + async def _handle_session_prompt(self, request: "web.Request") -> "web.Response": + """POST /api/sessions/{session_id}/prompt — persist Work Start work_ref.""" + auth_err = self._check_auth(request) + if auth_err: + return auth_err + session_id = request.match_info["session_id"] + session, err = self._get_existing_session_or_404(session_id) + if err: + return err + body, err = await self._read_json_body(request) + if err: + return err + work_ref = str(body.get("work_ref") or body.get("work_id") or "").strip() + if work_ref: + db = self._ensure_session_db() + owner = str(body.get("owner") or "").strip() or None + profile = str(body.get("profile") or "").strip() or None + db.attach_session_work(session_id, work_ref, owner=owner, profile=profile) + refreshed = db.get_session(session_id) + if refreshed: + session = refreshed + if not session: + return web.json_response( + _openai_error(f"Session not found: {session_id}", code="session_not_found"), + status=404, + ) + return web.json_response({ + "object": "hermes.session", + "accepted": True, + "ok": True, + "session_id": session_id, + "session": self._session_response(session), + }) + async def _handle_delete_session(self, request: "web.Request") -> "web.Response": """DELETE /api/sessions/{session_id}.""" auth_err = self._check_auth(request) @@ -4102,6 +4139,13 @@ async def connect(self) -> bool: self._app.router.add_get("/api/sessions/{session_id}", self._handle_get_session) self._app.router.add_patch("/api/sessions/{session_id}", self._handle_patch_session) self._app.router.add_delete("/api/sessions/{session_id}", self._handle_delete_session) + self._app.router.add_post("/api/sessions/{session_id}/prompt", self._handle_session_prompt) + self._app.router.add_get("/api/profiles/sessions", self._handle_list_sessions) + self._app.router.add_get("/api/profiles/sessions/{session_id}", self._handle_get_session) + self._app.router.add_post("/api/profiles/sessions/{session_id}/prompt", self._handle_session_prompt) + self._app.router.add_get("/sessions", self._handle_list_sessions) + self._app.router.add_get("/sessions/{session_id}", self._handle_get_session) + self._app.router.add_post("/sessions/{session_id}/prompt", self._handle_session_prompt) self._app.router.add_get("/api/sessions/{session_id}/messages", self._handle_session_messages) self._app.router.add_post("/api/sessions/{session_id}/fork", self._handle_fork_session) self._app.router.add_post("/api/sessions/{session_id}/chat", self._handle_session_chat) diff --git a/hermes_cli/web_server.py b/hermes_cli/web_server.py index b9b6907692f7d..a8ded51998566 100644 --- a/hermes_cli/web_server.py +++ b/hermes_cli/web_server.py @@ -1512,6 +1512,7 @@ async def get_sessions( archived_only=archived_only, ) now = time.time() + from hermes_state import apply_session_live_work for s in sessions: s["is_active"] = ( s.get("ended_at") is None @@ -1519,6 +1520,7 @@ async def get_sessions( ) # SQLite stores the flag as 0/1; expose a real JSON boolean. s["archived"] = bool(s.get("archived")) + apply_session_live_work(s) return {"sessions": sessions, "total": total, "limit": limit, "offset": offset} finally: db.close() @@ -4471,18 +4473,66 @@ async def get_session_stats(): @app.get("/api/sessions/{session_id}") async def get_session_detail(session_id: str): - from hermes_state import SessionDB + from hermes_state import SessionDB, apply_session_live_work db = SessionDB() try: sid = db.resolve_session_id(session_id) session = db.get_session(sid) if sid else None if not session: raise HTTPException(status_code=404, detail="Session not found") - return session + session["archived"] = bool(session.get("archived")) + return apply_session_live_work(session) finally: db.close() +def _session_prompt_work_ref(body: Dict[str, Any]) -> str: + raw = body.get("work_ref") + if raw is None: + raw = body.get("work_id") + return str(raw or "").strip() + + +async def _prompt_session_work(session_id: str, body: Dict[str, Any]) -> Dict[str, Any]: + """Persist Work Start ``work_ref`` onto the Hermes session store.""" + from hermes_state import SessionDB, apply_session_live_work + db = SessionDB() + try: + sid = db.resolve_session_id(session_id) + if not sid: + raise HTTPException(status_code=404, detail="Session not found") + work_ref = _session_prompt_work_ref(body) + if work_ref: + owner = str(body.get("owner") or "").strip() or None + profile = str(body.get("profile") or "").strip() or None + db.attach_session_work(sid, work_ref, owner=owner, profile=profile) + session = db.get_session(sid) + if not session: + raise HTTPException(status_code=404, detail="Session not found") + session["archived"] = bool(session.get("archived")) + apply_session_live_work(session) + return { + "accepted": True, + "ok": True, + "session_id": sid, + "session": session, + } + finally: + db.close() + + +@app.post("/api/sessions/{session_id}/prompt") +async def prompt_session_endpoint(session_id: str, request: Request): + """Work Start wake: attach ``work_ref`` Hermes owns, then list/get can observe it.""" + try: + body = await request.json() + except Exception: + body = {} + if not isinstance(body, dict): + body = {} + return await _prompt_session_work(session_id, body) + + @app.get("/api/sessions/{session_id}/latest-descendant") async def get_session_latest_descendant(session_id: str): @@ -6127,6 +6177,36 @@ async def list_profiles_endpoint(): return {"profiles": _fallback_profile_dicts(profiles_mod)} +# Literal ``/api/profiles/sessions`` family — profile-scoped alias of +# dashboard ``/api/sessions``. Register before ``/api/profiles/{name}`` +# so ``sessions`` is not captured as a profile name. +@app.get("/api/profiles/sessions") +async def get_profile_sessions( + limit: int = 20, + offset: int = 0, + min_messages: int = 0, + archived: str = "exclude", + order: str = "created", +): + return await get_sessions( + limit=limit, + offset=offset, + min_messages=min_messages, + archived=archived, + order=order, + ) + + +@app.get("/api/profiles/sessions/{session_id}") +async def get_profile_session_detail(session_id: str): + return await get_session_detail(session_id) + + +@app.post("/api/profiles/sessions/{session_id}/prompt") +async def prompt_profile_session_endpoint(session_id: str, request: Request): + return await prompt_session_endpoint(session_id, request) + + @app.post("/api/profiles") async def create_profile_endpoint(body: ProfileCreate): from hermes_cli import profiles as profiles_mod diff --git a/hermes_state.py b/hermes_state.py index f08acdce295ba..c5bb3db0775bf 100644 --- a/hermes_state.py +++ b/hermes_state.py @@ -110,6 +110,63 @@ def get_last_init_error() -> Optional[str]: return _last_init_error +def parse_session_metadata(raw: Any) -> Dict[str, Any]: + """Parse the Hermes-owned session metadata JSON blob.""" + if isinstance(raw, dict): + return dict(raw) + if not raw: + return {} + if isinstance(raw, str): + try: + parsed = json.loads(raw) + except (TypeError, ValueError): + return {} + return parsed if isinstance(parsed, dict) else {} + return {} + + +def session_owned_work_ids(metadata: Dict[str, Any]) -> List[str]: + """Return work ids Hermes stored. Empty means none — never invent.""" + raw = metadata.get("work_ids") + if raw is None: + raw = metadata.get("work_refs") + if isinstance(raw, str): + raw = [raw] + if not isinstance(raw, (list, tuple)): + return [] + seen = set() + owned: List[str] = [] + for item in raw: + work_id = str(item or "").strip() + if not work_id or work_id in seen: + continue + seen.add(work_id) + owned.append(work_id) + return owned + + +def apply_session_live_work(session: Dict[str, Any]) -> Dict[str, Any]: + """Project Hermes-owned ``live`` and ``metadata.work_ids`` onto a session row. + + ``is_active`` is a dashboard activity heuristic and is not live. A + session is live only when Hermes stored that fact (Work Start wake). + Work ids are only those Hermes persisted — omit/empty stays honest. + """ + meta = parse_session_metadata(session.get("metadata")) + work_ids = session_owned_work_ids(meta) + archived = bool(session.get("archived")) + live = bool(meta.get("live")) and not archived + session["live"] = live + session["metadata"] = {"work_ids": work_ids} + owner = str(meta.get("owner") or session.get("owner") or "").strip() + profile = str(meta.get("profile") or session.get("profile") or "").strip() + if owner: + session["owner"] = owner + if profile: + session["profile"] = profile + return session + + def format_session_db_unavailable(prefix: str = "Session database not available") -> str: """Format a user-facing 'session DB unavailable' message with cause. @@ -265,6 +322,7 @@ def _log_wal_fallback_once(db_label: str, exc: Exception) -> None: handoff_error TEXT, rewind_count INTEGER NOT NULL DEFAULT 0, archived INTEGER NOT NULL DEFAULT 0, + metadata TEXT, FOREIGN KEY (parent_session_id) REFERENCES sessions(id) ); @@ -1444,6 +1502,57 @@ def _do(conn): rowcount = self._execute_write(_do) return rowcount > 0 + def get_session_metadata(self, session_id: str) -> Dict[str, Any]: + """Return Hermes-owned session metadata, or ``{}`` if unset.""" + session = self.get_session(session_id) + if not session: + return {} + return parse_session_metadata(session.get("metadata")) + + def set_session_metadata(self, session_id: str, metadata: Dict[str, Any]) -> bool: + """Replace Hermes-owned session metadata. Returns True if a row updated.""" + payload = json.dumps(metadata if isinstance(metadata, dict) else {}) + + def _do(conn): + cursor = conn.execute( + "UPDATE sessions SET metadata = ? WHERE id = ?", + (payload, session_id), + ) + return cursor.rowcount + + return self._execute_write(_do) > 0 + + def attach_session_work( + self, + session_id: str, + work_ref: str, + *, + owner: Optional[str] = None, + profile: Optional[str] = None, + ) -> bool: + """Persist a work id this session owns and mark the session live. + + ``work_ref`` is required. Empty/missing refs are refused so list/get + never invent work. Owner/profile are stored only when the wake + supplies them — this path does not mint a default identity. + """ + work_id = str(work_ref or "").strip() + if not work_id or not self.get_session(session_id): + return False + meta = self.get_session_metadata(session_id) + work_ids = session_owned_work_ids(meta) + if work_id not in work_ids: + work_ids.append(work_id) + meta["work_ids"] = work_ids + meta["live"] = True + owner_id = str(owner or "").strip() + profile_id = str(profile or "").strip() + if owner_id: + meta["owner"] = owner_id + if profile_id: + meta["profile"] = profile_id + return self.set_session_metadata(session_id, meta) + def get_session_by_title(self, title: str) -> Optional[Dict[str, Any]]: """Look up a session by exact title. Returns session dict or None.""" with self._lock: @@ -1743,7 +1852,7 @@ def list_sessions_rich( for key in ( "id", "ended_at", "end_reason", "message_count", "tool_call_count", "title", "last_active", "preview", - "model", "system_prompt", "cwd", + "model", "system_prompt", "cwd", "metadata", ): if key in tip_row: merged[key] = tip_row[key] diff --git a/tests/gateway/test_api_server.py b/tests/gateway/test_api_server.py index c042fd556c696..6345acb79988a 100644 --- a/tests/gateway/test_api_server.py +++ b/tests/gateway/test_api_server.py @@ -3495,3 +3495,78 @@ async def test_capabilities_advertises_session_key_header(self, adapter): assert resp.status == 200 data = await resp.json() assert data["features"]["session_key_header"] == "X-Hermes-Session-Key" + + +def _session_app(adapter: APIServerAdapter) -> web.Application: + """Minimal aiohttp app with the session list/get/prompt surface.""" + mws = [mw for mw in (cors_middleware, security_headers_middleware) if mw is not None] + app = web.Application(middlewares=mws) + app["api_server_adapter"] = adapter + app.router.add_get("/api/sessions", adapter._handle_list_sessions) + app.router.add_get("/api/sessions/{session_id}", adapter._handle_get_session) + app.router.add_post("/api/sessions/{session_id}/prompt", adapter._handle_session_prompt) + app.router.add_get("/api/profiles/sessions", adapter._handle_list_sessions) + app.router.add_get("/api/profiles/sessions/{session_id}", adapter._handle_get_session) + app.router.add_post("/api/profiles/sessions/{session_id}/prompt", adapter._handle_session_prompt) + return app + + +class TestApiServerSessionLiveWork: + """api_server list/get/prompt must emit Hermes-owned live+work, not invent it.""" + + @pytest.mark.asyncio + async def test_wake_then_list_get_show_live_work(self, adapter, tmp_path, monkeypatch): + from hermes_state import SessionDB + + db_path = tmp_path / "sessions.db" + db = SessionDB(db_path=db_path) + db.create_session(session_id="api-wake", source="api_server") + monkeypatch.setattr(adapter, "_ensure_session_db", lambda: db) + try: + app = _session_app(adapter) + async with TestClient(TestServer(app)) as cli: + wake = await cli.post( + "/api/sessions/api-wake/prompt", + json={"work_ref": "card-1", "owner": "alpha", "profile": "default"}, + ) + assert wake.status == 200 + body = await wake.json() + assert body["session"]["live"] is True + assert body["session"]["metadata"]["work_ids"] == ["card-1"] + + listed = await cli.get("/api/sessions") + rows = (await listed.json())["data"] + row = next(s for s in rows if s["id"] == "api-wake") + assert row["live"] is True + assert row["metadata"]["work_ids"] == ["card-1"] + assert "is_active" not in row + + got = await cli.get("/api/sessions/api-wake") + session = (await got.json())["session"] + assert session["live"] is True + assert session["metadata"]["work_ids"] == ["card-1"] + + profile_list = await cli.get("/api/profiles/sessions") + prow = next(s for s in (await profile_list.json())["data"] if s["id"] == "api-wake") + assert prow["live"] is True + assert prow["metadata"]["work_ids"] == ["card-1"] + finally: + db.close() + + @pytest.mark.asyncio + async def test_list_without_wake_does_not_invent_work(self, adapter, tmp_path, monkeypatch): + from hermes_state import SessionDB + + db_path = tmp_path / "sessions.db" + db = SessionDB(db_path=db_path) + db.create_session(session_id="api-idle", source="api_server") + monkeypatch.setattr(adapter, "_ensure_session_db", lambda: db) + try: + app = _session_app(adapter) + async with TestClient(TestServer(app)) as cli: + listed = await cli.get("/api/sessions") + row = next(s for s in (await listed.json())["data"] if s["id"] == "api-idle") + assert row["live"] is False + assert row["metadata"]["work_ids"] == [] + finally: + db.close() diff --git a/tests/hermes_cli/test_web_server.py b/tests/hermes_cli/test_web_server.py index cac40c8009a69..a4878fde5988c 100644 --- a/tests/hermes_cli/test_web_server.py +++ b/tests/hermes_cli/test_web_server.py @@ -441,6 +441,91 @@ def test_get_sessions_archived_is_boolean(self): row = next(s for s in self.client.get("/api/sessions").json()["sessions"] if s["id"] == "bool-arch") assert row["archived"] is False + def test_wake_with_work_ref_lists_and_gets_live_work(self): + """After POST /prompt with work_ref, list/get emit Hermes-owned live+work.""" + from hermes_state import SessionDB + + db = SessionDB() + try: + db.create_session(session_id="wake-owner", source="cli") + finally: + db.close() + + wake = self.client.post( + "/api/sessions/wake-owner/prompt", + json={"work_ref": "card-1", "owner": "alpha", "profile": "default"}, + ) + assert wake.status_code == 200 + woken = wake.json()["session"] + assert woken["live"] is True + assert woken["metadata"]["work_ids"] == ["card-1"] + assert woken["owner"] == "alpha" + assert woken["profile"] == "default" + + listed = next( + s for s in self.client.get("/api/sessions").json()["sessions"] + if s["id"] == "wake-owner" + ) + assert listed["live"] is True + assert listed["metadata"]["work_ids"] == ["card-1"] + assert listed["is_active"] is True + + detail = self.client.get("/api/sessions/wake-owner").json() + assert detail["live"] is True + assert detail["metadata"]["work_ids"] == ["card-1"] + + profile_listed = next( + s for s in self.client.get("/api/profiles/sessions").json()["sessions"] + if s["id"] == "wake-owner" + ) + assert profile_listed["live"] is True + assert profile_listed["metadata"]["work_ids"] == ["card-1"] + assert self.client.get("/api/profiles/sessions/wake-owner").json()["live"] is True + + def test_prompt_without_work_ref_does_not_invent_work_or_live(self): + from hermes_state import SessionDB + + db = SessionDB() + try: + db.create_session(session_id="no-work", source="cli") + finally: + db.close() + + resp = self.client.post("/api/sessions/no-work/prompt", json={"prompt": "hello"}) + assert resp.status_code == 200 + session = resp.json()["session"] + assert session["live"] is False + assert session["metadata"]["work_ids"] == [] + + listed = next( + s for s in self.client.get("/api/sessions").json()["sessions"] + if s["id"] == "no-work" + ) + assert listed["is_active"] is True + assert listed["live"] is False + assert listed["metadata"]["work_ids"] == [] + + def test_is_active_alone_is_not_live(self): + """Dashboard recency (is_active) is not live.""" + from hermes_state import SessionDB + + db = SessionDB() + try: + db.create_session(session_id="active-only", source="cli") + finally: + db.close() + + listed = next( + s for s in self.client.get("/api/sessions").json()["sessions"] + if s["id"] == "active-only" + ) + assert listed["is_active"] is True + assert listed["live"] is False + assert listed["metadata"]["work_ids"] == [] + detail = self.client.get("/api/sessions/active-only").json() + assert detail["live"] is False + assert detail["metadata"]["work_ids"] == [] + def test_rename_response_omits_archived_when_not_set(self): """Title-only PATCH keeps its legacy {ok, title} response shape.""" from hermes_state import SessionDB diff --git a/tests/test_hermes_state.py b/tests/test_hermes_state.py index 572fd6489d3d3..57d73ee8464f3 100644 --- a/tests/test_hermes_state.py +++ b/tests/test_hermes_state.py @@ -4,7 +4,12 @@ import time import pytest -from hermes_state import SCHEMA_SQL, SessionDB +from hermes_state import ( + SCHEMA_SQL, + SessionDB, + apply_session_live_work, + session_owned_work_ids, +) class _NoFtsCursor(sqlite3.Cursor): @@ -3748,6 +3753,53 @@ def execute(self, sql, params=()): ) +class TestSessionLiveWork: + """Hermes-owned live + work_ids. is_active is not this.""" + + def test_attach_work_marks_live_and_stores_ids(self, db): + db.create_session(session_id="s1", source="cli") + assert db.attach_session_work("s1", "work-a", owner="alpha", profile="default") + assert db.attach_session_work("s1", "work-a") is True + meta = db.get_session_metadata("s1") + assert meta["live"] is True + assert meta["work_ids"] == ["work-a"] + row = db.get_session("s1") + assert row is not None + viewed = apply_session_live_work(row) + assert viewed["live"] is True + assert viewed["metadata"]["work_ids"] == ["work-a"] + assert viewed["owner"] == "alpha" + assert viewed["profile"] == "default" + + def test_attach_empty_work_ref_is_refused(self, db): + db.create_session(session_id="s1", source="cli") + assert db.attach_session_work("s1", " ") is False + row = db.get_session("s1") + assert row is not None + viewed = apply_session_live_work(row) + assert viewed["live"] is False + assert viewed["metadata"]["work_ids"] == [] + + def test_apply_does_not_invent_work_or_live(self): + viewed = apply_session_live_work({"id": "s1", "archived": 0, "metadata": None}) + assert viewed["live"] is False + assert viewed["metadata"]["work_ids"] == [] + assert "owner" not in viewed + + def test_archived_session_is_not_live(self, db): + db.create_session(session_id="s1", source="cli") + db.attach_session_work("s1", "work-a") + db.set_session_archived("s1", True) + row = db.get_session("s1") + assert row is not None + viewed = apply_session_live_work(row) + assert viewed["live"] is False + assert viewed["metadata"]["work_ids"] == ["work-a"] + + def test_owned_work_ids_dedupe_and_ignore_empty(self): + assert session_owned_work_ids({"work_ids": ["a", "a", "", "b"]}) == ["a", "b"] + + class TestSessionArchive: """Soft-archiving hides a session from default listings without deleting it."""