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

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

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

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

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

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

@@ -469,31 +469,6 @@ 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.2 → licos_agent_runtime-0.3.4}/src/licos_agent_runtime/harness_config.py

@@ -25,10 +25,6 @@ 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"
 
@@ -81,7 +77,6 @@ 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 → licos_agent_runtime-0.3.4}/src/licos_agent_runtime/harness_verification.py

@@ -18,11 +18,14 @@ _LINK = re.compile(r"\[([^\]]+)\]\((https?://[^\s)]+)\)")
 _FILE_LINK_LABEL = re.compile(r"下载|文件|附件|文档|报告|download|file|document|report", re.I)
 _DELIVERY_CLAIM = re.compile(r"已上传|上传成功|可下载|下载链接\s*[:：]")
 _NEGATION = re.compile(r"未|没有|无法|不能|不会|尚无|尚未|无可用|不提供")
+_CONDITIONAL = re.compile(r"若|如果|假如|假设|如需")
 
 
 def _claims_file_delivery(answer: str) -> bool:
     for clause in re.split(r"[，。；;\n]", answer):
         for claim in _DELIVERY_CLAIM.finditer(clause):
+            if _CONDITIONAL.search(clause[:claim.start()]):
+                continue
             if not _NEGATION.search(clause[max(0, claim.start() - 12):claim.start()]):
                 return True
     return False

{licos_agent_runtime-0.3.2 → licos_agent_runtime-0.3.4}/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
-                    await turn.commit(extract_answer(result))
+                    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:
-                            await turn.commit("".join(answers) if run_opt.stream_mode == "messages" else answers[-1])
+                            turn.commit("".join(answers) if run_opt.stream_mode == "messages" else answers[-1])
                 except BaseException as exc:
                     await queue.put(exc)
                 finally:
@@ -906,20 +906,6 @@ 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.2 → licos_agent_runtime-0.3.4}/src/licos_agent_runtime/session_memory.py

@@ -12,7 +12,6 @@ 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
 
@@ -35,17 +34,10 @@ 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 = ""
 
-    async def commit(self, answer: str) -> None:
+    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()
@@ -56,13 +48,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) or settings.history.enabled)
+            and settings.memory.enabled
+            and settings.memory.recent_turns
             and isinstance(request.get("session_id"), str)
             and request["session_id"].strip()
             and not request.get("messages")
@@ -115,21 +107,11 @@ class SessionMemory:
             if session.generation != self._generation or now - session.touched > settings.memory.idle_ttl_seconds:
                 session.turns.clear()
                 session.generation = self._generation
-            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 []
+            while len(session.turns) > settings.memory.recent_turns:
+                session.turns.popleft()
             session.touched = now
             history: list[dict[str, str]] = []
-            for user, assistant in turns:
+            for user, assistant in session.turns:
                 history.extend(({"role": "user", "content": user}, {"role": "assistant", "content": assistant}))
             current = payload.get("messages")
             prepared = dict(payload)
@@ -142,25 +124,7 @@ 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,
-                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)
+            yield MemoryTurn(prepared, text, session, settings.memory.recent_turns)
 
     def clear(self) -> None:
         self._generation += 1

{licos_agent_runtime-0.3.2 → licos_agent_runtime-0.3.4}/src/licos_agent_runtime/verify.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import json
+import os
 from pathlib import Path
 from typing import Any
 from uuid import uuid4
@@ -116,7 +117,9 @@ def verify_project(*, cases_path: str, base_url: str, output_path: str, request_
         report["request_timeout_seconds"] = timeout
         report["project"] = validate_project()
         cases = json.loads(Path(cases_path).read_text(encoding="utf-8"))
-        with httpx.Client(base_url=base_url.rstrip("/") + "/", timeout=timeout, trust_env=False) as client:
+        token = os.environ.get("LICOS_AGENT_VERIFY_BEARER_TOKEN")
+        headers = {"Authorization": f"Bearer {token}"} if token else {}
+        with httpx.Client(base_url=base_url.rstrip("/") + "/", timeout=timeout, headers=headers, trust_env=False) as client:
             report["cases"] = verify_cases(client, cases)
         report["status"] = "passed"
         return report

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

@@ -230,7 +230,7 @@ class HarnessTests(unittest.TestCase):
                                       {"input": "first"}, ctx, settings, root) as turn:
                     started.set()
                     await release.wait()
-                    await turn.commit("answer-first")
+                    turn.commit("answer-first")
 
             async def second():
                 async with memory.use({"session_id": "same", "input": "second"},
@@ -348,107 +348,6 @@ 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:
@@ -625,6 +524,14 @@ class HarnessTests(unittest.TestCase):
             ToolMessage("Wrote 18 bytes", name="write_file", tool_call_id="w1"),
             AIMessage("文件已写入并核对；没有生成下载链接，也未上传。"),
         ]))
+        self.assertIsNone(verify_tool_evidence([
+            HumanMessage("explain message input"),
+            AIMessage("或作为附件上传（若已上传，可继续处理）。如果确实需要一份可下载的文件，我会先上传。"),
+        ]))
+        self.assertIn("verified upload URL", verify_tool_evidence([
+            HumanMessage("deliver a file"),
+            AIMessage("文件已上传，可以下载。"),
+        ]))
         self.assertIn("lack a successful upload", verify_tool_evidence([
             HumanMessage("deliver a report"),
             ToolMessage("Wrote 18 bytes", name="write_file", tool_call_id="w1"),

{licos_agent_runtime-0.3.2 → licos_agent_runtime-0.3.4}/tests/test_runtime_config.py

@@ -44,3 +44,10 @@ class RuntimeConfigTests(unittest.TestCase):
             report = json.loads(target.read_text(encoding="utf-8"))
             self.assertEqual(report["status"], "failed")
             self.assertIn("positive finite", report["error"])
+
+    def test_verification_sends_authenticated_user_token(self):
+        with tempfile.TemporaryDirectory() as root, patch.dict(os.environ, {"LICOS_AGENT_VERIFY_BEARER_TOKEN": "dev-user-token"}), patch("licos_agent_runtime.verify.validate_project", return_value={}), patch("licos_agent_runtime.verify.verify_cases", return_value=[]), patch("licos_agent_runtime.verify.httpx.Client") as client:
+            cases = Path(root) / "cases.json"
+            cases.write_text("[]", encoding="utf-8")
+            verify_project(cases_path=str(cases), base_url="http://localhost:5000", output_path=str(Path(root) / "report.json"))
+            self.assertEqual(client.call_args.kwargs["headers"], {"Authorization": "Bearer dev-user-token"})

licos_agent_runtime-0.3.2/src/licos_agent_runtime/project_history.py

@@ -1,69 +0,0 @@
-"""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
-        )