licos-agent-runtime 0.3.1__tar.gz → 0.3.2__tar.gz

{licos_agent_runtime-0.3.1 → licos_agent_runtime-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: licos-agent-runtime
-Version: 0.3.1
+Version: 0.3.2
 Summary: LICOS Python agent runtime for LangGraph/LangChain projects
 Requires-Python: >=3.10
 Requires-Dist: fastapi<1,>=0.121

{licos_agent_runtime-0.3.1 → licos_agent_runtime-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "licos-agent-runtime"
-version = "0.3.1"
+version = "0.3.2"
 description = "LICOS Python agent runtime for LangGraph/LangChain projects"
 readme = "README.md"
 requires-python = ">=3.10"

{licos_agent_runtime-0.3.1 → licos_agent_runtime-0.3.2}/src/licos_agent_runtime/app.py

@@ -469,6 +469,31 @@ def create_app(service: GraphService | None = None) -> FastAPI:
         del request
         return runtime_service.agent_config_info()
 
+    @app.get("/agent/history/{session_id}")
+    async def http_agent_history(
+        session_id: str,
+        request: Request,
+        limit: int = Query(20, ge=1, le=100),
+        offset: int = Query(0, ge=0),
+    ) -> dict[str, Any]:
+        ctx = new_context(method="agent_history", headers=request.headers)
+        try:
+            return await runtime_service.conversation_history(session_id, ctx, limit, offset)
+        except LookupError as exc:
+            raise HTTPException(status_code=404, detail=str(exc)) from exc
+        except ValueError as exc:
+            raise HTTPException(status_code=401, detail=str(exc)) from exc
+
+    @app.delete("/agent/history/{session_id}")
+    async def http_agent_history_delete(session_id: str, request: Request) -> dict[str, Any]:
+        ctx = new_context(method="agent_history_delete", headers=request.headers)
+        try:
+            return await runtime_service.delete_conversation_history(session_id, ctx)
+        except LookupError as exc:
+            raise HTTPException(status_code=404, detail=str(exc)) from exc
+        except ValueError as exc:
+            raise HTTPException(status_code=401, detail=str(exc)) from exc
+
     @app.get("/run_records")
     async def http_run_records(
         request: Request,

{licos_agent_runtime-0.3.1 → licos_agent_runtime-0.3.2}/src/licos_agent_runtime/harness_config.py

@@ -25,6 +25,10 @@ class MemorySettings(_StrictModel):
     idle_ttl_seconds: int = Field(default=3600, ge=1)
 
 
+class HistorySettings(_StrictModel):
+    enabled: bool = False
+
+
 class PlanningSettings(_StrictModel):
     mode: Literal["off", "auto", "always"] = "auto"
 
@@ -77,6 +81,7 @@ class ThinkingSettings(_StrictModel):
 class HarnessSettings(_StrictModel):
     version: Literal[1]
     memory: MemorySettings = Field(default_factory=MemorySettings)
+    history: HistorySettings = Field(default_factory=HistorySettings)
     planning: PlanningSettings = Field(default_factory=PlanningSettings)
     context: ContextSettings = Field(default_factory=ContextSettings)
     execution: ExecutionSettings = Field(default_factory=ExecutionSettings)

licos_agent_runtime-0.3.2/src/licos_agent_runtime/project_history.py

@@ -0,0 +1,69 @@
+"""Opt-in completed-turn history stored in the current project database."""
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from licos_platform_sdk import database
+
+
+TABLE = "agent_conversation_turns"
+
+
+def _scope(user_id: str, session_id: str) -> list[dict[str, str]]:
+    return [
+        {"field": "user_id", "op": "eq", "value": user_id},
+        {"field": "session_id", "op": "eq", "value": session_id},
+    ]
+
+
+class ProjectHistory:
+    async def recent(self, user_id: str, session_id: str, limit: int) -> list[tuple[str, str]]:
+        result = await asyncio.to_thread(
+            database.query,
+            TABLE,
+            select=["user_text", "assistant_text"],
+            filters=_scope(user_id, session_id),
+            order_by=[
+                {"field": "created_at", "direction": "desc"},
+                {"field": "id", "direction": "desc"},
+            ],
+            limit=limit,
+        )
+        return [(row["user_text"], row["assistant_text"]) for row in reversed(result["data"])]
+
+    async def save(
+        self, user_id: str, session_id: str, run_id: str, user_text: str, assistant_text: str
+    ) -> None:
+        await asyncio.to_thread(
+            database.insert,
+            TABLE,
+            row={
+                "id": run_id,
+                "user_id": user_id,
+                "session_id": session_id,
+                "user_text": user_text,
+                "assistant_text": assistant_text,
+            },
+            returning=False,
+        )
+
+    async def page(self, user_id: str, session_id: str, limit: int, offset: int) -> dict[str, Any]:
+        return await asyncio.to_thread(
+            database.query,
+            TABLE,
+            select=["id", "user_text", "assistant_text", "created_at"],
+            filters=_scope(user_id, session_id),
+            order_by=[
+                {"field": "created_at", "direction": "desc"},
+                {"field": "id", "direction": "desc"},
+            ],
+            limit=limit,
+            offset=offset,
+            count=True,
+        )
+
+    async def delete(self, user_id: str, session_id: str) -> dict[str, Any]:
+        return await asyncio.to_thread(
+            database.delete, TABLE, filters=_scope(user_id, session_id), returning=False
+        )

{licos_agent_runtime-0.3.1 → licos_agent_runtime-0.3.2}/src/licos_agent_runtime/service.py

@@ -300,7 +300,7 @@ class GraphService:
                     result = await asyncio.wait_for(
                         invocation, timeout=snapshot.harness.execution.max_duration_seconds
                     ) if snapshot and snapshot.harness else await invocation
-                    turn.commit(extract_answer(result))
+                    await turn.commit(extract_answer(result))
             else:
                 payload = materialize_input_files(payload)
                 recorder.set_root_input(payload)
@@ -511,7 +511,7 @@ class GraphService:
                         else:
                             await consume()
                         if answers:
-                            turn.commit("".join(answers) if run_opt.stream_mode == "messages" else answers[-1])
+                            await turn.commit("".join(answers) if run_opt.stream_mode == "messages" else answers[-1])
                 except BaseException as exc:
                     await queue.put(exc)
                 finally:
@@ -906,6 +906,20 @@ class GraphService:
             **read_agent_config(),
         }
 
+    async def conversation_history(
+        self, session_id: str, ctx: Context, limit: int, offset: int
+    ) -> dict[str, Any]:
+        snapshot = self._agent_snapshot(ctx)
+        if snapshot is None or snapshot.harness is None or not snapshot.harness.history.enabled:
+            raise LookupError("Project database conversation history is disabled")
+        return await self._session_memory.history_page(ctx, snapshot.harness, session_id, limit, offset)
+
+    async def delete_conversation_history(self, session_id: str, ctx: Context) -> dict[str, Any]:
+        snapshot = self._agent_snapshot(ctx)
+        if snapshot is None or snapshot.harness is None or not snapshot.harness.history.enabled:
+            raise LookupError("Project database conversation history is disabled")
+        return await self._session_memory.history_delete(ctx, snapshot.harness, session_id)
+
     def agent_canvas(self) -> dict[str, Any]:
         if is_agent_project():
             return agent_canvas_response()

{licos_agent_runtime-0.3.1 → licos_agent_runtime-0.3.2}/src/licos_agent_runtime/session_memory.py

@@ -12,6 +12,7 @@ from typing import Any, AsyncIterator
 
 from .context import Context
 from .harness_config import HarnessSettings
+from .project_history import ProjectHistory
 from .session_files import session_user_id
 from .stream_protocol import extract_prompt_text
 
@@ -34,10 +35,17 @@ class MemoryTurn:
     user_text: str | None = None
     _session: _Session | None = None
     _window: int = 0
+    _history: ProjectHistory | None = None
+    _user_id: str = ""
+    _session_id: str = ""
+    _run_id: str = ""
 
-    def commit(self, answer: str) -> None:
+    async def commit(self, answer: str) -> None:
         if self._session is None or not self.user_text or not answer.strip():
             return
+        if self._history is not None:
+            await self._history.save(self._user_id, self._session_id, self._run_id, self.user_text, answer)
+            return
         self._session.turns.append((self.user_text, answer))
         while len(self._session.turns) > self._window:
             self._session.turns.popleft()
@@ -48,13 +56,13 @@ class SessionMemory:
     def __init__(self) -> None:
         self._sessions: OrderedDict[SessionKey, _Session] = OrderedDict()
         self._generation = 0
+        self._history = ProjectHistory()
 
     @staticmethod
     def _eligible(request: dict[str, Any], settings: HarnessSettings | None) -> bool:
         return bool(
             settings
-            and settings.memory.enabled
-            and settings.memory.recent_turns
+            and ((settings.memory.enabled and settings.memory.recent_turns) or settings.history.enabled)
             and isinstance(request.get("session_id"), str)
             and request["session_id"].strip()
             and not request.get("messages")
@@ -107,11 +115,21 @@ class SessionMemory:
             if session.generation != self._generation or now - session.touched > settings.memory.idle_ttl_seconds:
                 session.turns.clear()
                 session.generation = self._generation
-            while len(session.turns) > settings.memory.recent_turns:
-                session.turns.popleft()
+            if settings.history.enabled:
+                user_id = session_user_id(ctx)
+                session.turns.clear()
+                turns = (
+                    await self._history.recent(user_id, session_id, settings.memory.recent_turns)
+                    if settings.memory.enabled and settings.memory.recent_turns else []
+                )
+            else:
+                user_id = ""
+                while len(session.turns) > settings.memory.recent_turns:
+                    session.turns.popleft()
+                turns = session.turns if settings.memory.enabled else []
             session.touched = now
             history: list[dict[str, str]] = []
-            for user, assistant in session.turns:
+            for user, assistant in turns:
                 history.extend(({"role": "user", "content": user}, {"role": "assistant", "content": assistant}))
             current = payload.get("messages")
             prepared = dict(payload)
@@ -124,7 +142,25 @@ class SessionMemory:
             if text is None:
                 value = payload.get("input")
                 text = value if isinstance(value, str) else None
-            yield MemoryTurn(prepared, text, session, settings.memory.recent_turns)
+            yield MemoryTurn(
+                prepared, text, session, settings.memory.recent_turns,
+                self._history if settings.history.enabled else None,
+                user_id, session_id, ctx.run_id,
+            )
+
+    async def history_page(
+        self, ctx: Context, settings: HarnessSettings, session_id: str, limit: int, offset: int
+    ) -> dict[str, Any]:
+        if not settings.history.enabled:
+            raise ValueError("Project database conversation history is disabled")
+        return await self._history.page(session_user_id(ctx), session_id, limit, offset)
+
+    async def history_delete(
+        self, ctx: Context, settings: HarnessSettings, session_id: str
+    ) -> dict[str, Any]:
+        if not settings.history.enabled:
+            raise ValueError("Project database conversation history is disabled")
+        return await self._history.delete(session_user_id(ctx), session_id)
 
     def clear(self) -> None:
         self._generation += 1

{licos_agent_runtime-0.3.1 → licos_agent_runtime-0.3.2}/tests/test_harness.py

@@ -230,7 +230,7 @@ class HarnessTests(unittest.TestCase):
                                       {"input": "first"}, ctx, settings, root) as turn:
                     started.set()
                     await release.wait()
-                    turn.commit("answer-first")
+                    await turn.commit("answer-first")
 
             async def second():
                 async with memory.use({"session_id": "same", "input": "second"},
@@ -348,6 +348,107 @@ class HarnessTests(unittest.TestCase):
 
         asyncio.run(run())
 
+    def test_project_database_history_persists_across_runtime_restart_and_isolates_users(self):
+        rows = []
+
+        def query(_table, *, filters, limit, offset=0, **_kwargs):
+            scoped = [row for row in rows if all(row[item["field"]] == item["value"] for item in filters)]
+            scoped.reverse()
+            return {"data": scoped[offset:offset + limit], "count": len(scoped)}
+
+        def insert(_table, *, row, returning):
+            self.assertFalse(returning)
+            rows.append({**row, "created_at": len(rows)})
+            return {"affectedRows": 1}
+
+        def delete(_table, *, filters, returning):
+            self.assertFalse(returning)
+            before = len(rows)
+            rows[:] = [row for row in rows if not all(row[item["field"]] == item["value"] for item in filters)]
+            return {"affectedRows": before - len(rows)}
+
+        async def run():
+            with tempfile.TemporaryDirectory(dir=".tmp") as directory:
+                root = Path(directory)
+                (root / "config").mkdir()
+                (root / "config/agent_llm_config.json").write_text(json.dumps({
+                    "harness": {"version": 1, "planning": {"mode": "off"},
+                                "history": {"enabled": True}},
+                }), encoding="utf-8")
+                model = HarnessModel()
+                graph = build_agent_graph(model, system_prompt="test")
+                service = GraphService()
+
+                async def send(text, user="user-1", session="same"):
+                    ctx = new_context("run")
+                    ctx.identity.current_user_id = user
+                    await service.run({"input": text, "session_id": session}, ctx)
+
+                with (
+                    patch.dict(os.environ, {"LICOS_PROJECT_PATH": str(root), "LICOS_WORKSPACE_PATH": str(root)}),
+                    patch("licos_agent_runtime.service.is_agent_project", return_value=True),
+                    patch("licos_agent_runtime.project_history.database.query", side_effect=query),
+                    patch("licos_agent_runtime.project_history.database.insert", side_effect=insert),
+                    patch("licos_agent_runtime.project_history.database.delete", side_effect=delete),
+                    patch.object(GraphService, "_get_graph", return_value=graph),
+                ):
+                    for number in range(1, 5):
+                        await send(f"turn-{number}")
+                    self.assertEqual(len(rows), 4)
+                    service = GraphService()
+                    await send("turn-5")
+                    self.assertEqual(
+                        [message.content for message in model.seen[-1] if isinstance(message, HumanMessage)],
+                        ["turn-2", "turn-3", "turn-4", "turn-5"],
+                    )
+                    await send("another-user", user="user-2")
+                    self.assertEqual(
+                        [message.content for message in model.seen[-1] if isinstance(message, HumanMessage)],
+                        ["another-user"],
+                    )
+                    await send("another-session", session="other")
+                    self.assertEqual(
+                        [message.content for message in model.seen[-1] if isinstance(message, HumanMessage)],
+                        ["another-session"],
+                    )
+                    ctx = new_context("history")
+                    ctx.identity.current_user_id = "user-1"
+                    page = await service.conversation_history("same", ctx, 2, 1)
+                    self.assertEqual(page["count"], 5)
+                    self.assertEqual([row["user_text"] for row in page["data"]], ["turn-4", "turn-3"])
+                    ctx.identity.current_user_id = "user-2"
+                    page = await service.conversation_history("same", ctx, 20, 0)
+                    self.assertEqual([row["user_text"] for row in page["data"]], ["another-user"])
+                    self.assertEqual((await service.delete_conversation_history("same", ctx))["affectedRows"], 1)
+                    ctx.identity.current_user_id = "user-1"
+                    self.assertEqual((await service.conversation_history("same", ctx, 20, 0))["count"], 5)
+
+        asyncio.run(run())
+
+    def test_enabled_project_database_history_write_failure_fails_the_run(self):
+        async def run():
+            with tempfile.TemporaryDirectory(dir=".tmp") as directory:
+                root = Path(directory)
+                (root / "config").mkdir()
+                (root / "config/agent_llm_config.json").write_text(json.dumps({
+                    "harness": {"version": 1, "planning": {"mode": "off"},
+                                "history": {"enabled": True}},
+                }), encoding="utf-8")
+                service = GraphService()
+                ctx = new_context("run")
+                ctx.identity.current_user_id = "user-1"
+                with (
+                    patch.dict(os.environ, {"LICOS_PROJECT_PATH": str(root), "LICOS_WORKSPACE_PATH": str(root)}),
+                    patch("licos_agent_runtime.service.is_agent_project", return_value=True),
+                    patch("licos_agent_runtime.project_history.database.query", return_value={"data": []}),
+                    patch("licos_agent_runtime.project_history.database.insert", side_effect=RuntimeError("write failed")),
+                    patch.object(service, "_get_graph", return_value=build_agent_graph(HarnessModel(), system_prompt="test")),
+                ):
+                    with self.assertRaisesRegex(RuntimeError, "write failed"):
+                        await service.run({"input": "hello", "session_id": "same"}, ctx)
+
+        asyncio.run(run())
+
     def test_stream_commits_only_finished_response(self):
         async def run():
             with tempfile.TemporaryDirectory(dir=".tmp") as directory: