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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: licos-agent-runtime
-Version: 0.3.0
+Version: 0.3.2
 Summary: LICOS Python agent runtime for LangGraph/LangChain projects
 Requires-Python: >=3.10
 Requires-Dist: fastapi<1,>=0.121
@@ -14,7 +14,7 @@ Requires-Dist: langgraph-prebuilt<2,>=1.0
 Requires-Dist: langgraph-sdk<1,>=0.3
 Requires-Dist: langgraph<2,>=1.1
 Requires-Dist: langsmith<1,>=0.4
-Requires-Dist: licos-dev-sdk>=0.4.8
+Requires-Dist: licos-dev-sdk>=0.4.9
 Requires-Dist: licos-platform-sdk>=0.5.7
 Requires-Dist: pydantic<3,>=2.12
 Requires-Dist: pyyaml<7,>=6

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "licos-agent-runtime"
-version = "0.3.0"
+version = "0.3.2"
 description = "LICOS Python agent runtime for LangGraph/LangChain projects"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -22,7 +22,7 @@ dependencies = [
     "langsmith>=0.4,<1",
     "httpx>=0.27,<1",
     "licos-platform-sdk>=0.5.7",
-    "licos-dev-sdk>=0.4.8",
+    "licos-dev-sdk>=0.4.9",
     "filelock>=3.16,<4",
     "PyYAML>=6,<7",
     "wcmatch>=10,<11",

{licos_agent_runtime-0.3.0 → licos_agent_runtime-0.3.2}/src/licos_agent_runtime/agent_config.py

@@ -5,6 +5,7 @@ from pathlib import Path
 from typing import Any
 
 from .graph_loader import project_root
+from .harness_config import load_agent_project_config
 
 AGENT_CONFIG_RELATIVE_PATH = Path("config") / "agent_llm_config.json"
 AGENT_CONFIG_PATH = AGENT_CONFIG_RELATIVE_PATH.as_posix()
@@ -19,6 +20,9 @@ def _empty_payload(*, exists: bool = False) -> dict[str, Any]:
         "up": "",
         "tools": [],
         "raw": {},
+        "harness": None,
+        "harness_version": 0,
+        "harness_digest": None,
     }
 
 
@@ -67,4 +71,14 @@ def read_agent_config(root: Path | None = None) -> dict[str, Any]:
     payload["sp"] = _text(raw.get("sp"))
     payload["up"] = _text(raw.get("up"))
     payload["tools"] = _tools(raw.get("tools"))
+    try:
+        snapshot = load_agent_project_config(base)
+    except (ValueError, TypeError) as exc:
+        payload["error"] = str(exc)
+        return payload
+    if snapshot is not None:
+        payload["harness_digest"] = snapshot.digest
+        if snapshot.harness is not None:
+            payload["harness"] = snapshot.harness.model_dump()
+            payload["harness_version"] = snapshot.harness.version
     return payload

licos_agent_runtime-0.3.2/src/licos_agent_runtime/agent_graph.py

@@ -0,0 +1,249 @@
+"""Business-neutral model/tool loop; applications own model and tool creation."""
+from __future__ import annotations
+
+import json
+import time
+from typing import Annotated, Any, Sequence
+from typing_extensions import TypedDict
+
+from langchain_core.messages import AnyMessage, HumanMessage, SystemMessage, ToolMessage
+from langchain_core.runnables import RunnableConfig, RunnableLambda
+from langchain_core.tools import BaseTool
+from langgraph.graph import END, START, StateGraph
+from langgraph.graph.message import add_messages
+from langgraph.prebuilt import ToolNode, tools_condition
+
+from .harness_config import HarnessSettings
+from .harness_execution import HarnessLimitError, HarnessRun
+from .harness_planning import parse_plan, planning_messages
+from .harness_approval import ApprovalRegistry
+from .context import Context
+from .harness_verification import HarnessVerificationError, ProjectVerifier, verify_tool_evidence
+
+
+class AgentState(TypedDict, total=False):
+    messages: Annotated[list[AnyMessage], add_messages]
+    input: str | list[dict[str, Any]] | None
+    event: dict[str, Any] | None
+    attachments: list[dict[str, Any]]
+    files: list[dict[str, Any]]
+    references: list[dict[str, Any]]
+    repair_attempts: int
+    verification_issue: str | None
+    plan: list[str]
+    plan_reason: str
+
+
+def validate_tool_registry(tools: Sequence[BaseTool], configured_names: list[str]) -> None:
+    names = [tool.name for tool in tools]
+    if len(set(names)) != len(names) or len(set(configured_names)) != len(configured_names):
+        raise ValueError("Agent tool names must be unique")
+    if set(names) != set(configured_names):
+        raise ValueError(
+            f"Agent tool registry does not match config: registered={names}, configured={configured_names}"
+        )
+
+
+def _prepare_input(state: AgentState) -> dict[str, Any]:
+    existing = state.get("messages", [])
+    added: list[AnyMessage] = []
+    content = state.get("input")
+    if content is not None:
+        if not isinstance(content, (str, list)):
+            raise ValueError("input must be text or message content blocks; use event for structured events")
+        if content and not (
+            existing and isinstance(existing[-1], HumanMessage) and existing[-1].content == content
+        ):
+            added.append(HumanMessage(content=content))
+    event = state.get("event")
+    if event is not None:
+        if not isinstance(event, dict) or not event:
+            raise ValueError("event must be a non-empty JSON object")
+        added.append(HumanMessage(content=json.dumps({"event": event}, ensure_ascii=False)))
+    if not existing and not added:
+        raise ValueError("Agent request requires non-empty input, messages or event")
+    # Consume request fields so a checkpoint cannot replay them on the next turn.
+    return {"messages": added, "input": None, "event": None}
+
+
+def recent_turns(messages: list[AnyMessage], max_messages: int) -> list[AnyMessage]:
+    """Drop whole old turns, never split the current model/tool exchange.
+
+    The most recent turn may exceed this soft limit. LangGraph's recursion
+    limit bounds its execution; truncating tool pairs corrupts it.
+    """
+    # Adjacent user messages belong to the same turn until the model responds.
+    starts = [index for index, item in enumerate(messages)
+              if isinstance(item, HumanMessage)
+              and (index == 0 or not isinstance(messages[index - 1], HumanMessage))]
+    if not starts:
+        raise ValueError("Agent conversation requires a user message")
+    start = starts[0]
+    for next_start in starts[1:]:
+        if len(messages) - start <= max_messages:
+            break
+        start = next_start
+    return messages[start:]
+
+
+def build_agent_graph(
+    model: Any,
+    tools: Sequence[BaseTool] = (),
+    *,
+    system_prompt: str,
+    max_messages: int = 40,
+    checkpointer: Any = None,
+    config_path: str = "config/agent_llm_config.json",
+    harness: HarnessSettings | None = None,
+    harness_run: HarnessRun | None = None,
+    verifier: ProjectVerifier | None = None,
+    approvals: ApprovalRegistry | None = None,
+    ctx: Context | None = None,
+) -> Any:
+    if max_messages < 1:
+        raise ValueError("max_messages must be positive")
+    registered = list(tools)
+    validate_tool_registry(registered, [tool.name for tool in registered])
+    if harness is not None:
+        unknown = set(harness.tool_policy.require_approval) - {tool.name for tool in registered}
+        if unknown:
+            raise ValueError(f"Approval tools are not registered: {sorted(unknown)}")
+        if harness.tool_policy.require_approval and (approvals is None or ctx is None or harness_run is None):
+            raise ValueError("Tool approvals require a runtime request context and approval registry")
+        if harness.verification.mode == "project" and verifier is None:
+            raise ValueError("verification.mode=project requires a registered project verifier")
+    if harness_run is not None:
+        harness_run.tool_schema_tokens = sum(
+            len(json.dumps({"name": tool.name, "description": tool.description, "args": tool.args},
+                           ensure_ascii=False, default=str).encode("utf-8")) + 12
+            for tool in registered
+        )
+    bound_model = model.bind_tools(registered) if registered else model
+
+    def model_input(state: AgentState) -> list[AnyMessage]:
+        system = [SystemMessage(content=system_prompt)]
+        if state.get("plan"):
+            steps = "\n".join(f"{index}. {step}" for index, step in enumerate(state["plan"], start=1))
+            system.append(SystemMessage(content=f"Current task plan:\n{steps}\nCheck each step against tool results before claiming completion."))
+        conversation = state["messages"] if harness is not None else recent_turns(state["messages"], max_messages)
+        messages = [*system, *conversation]
+        return harness_run.fit_context(messages) if harness_run is not None else messages
+
+    def respond(state: AgentState, config: RunnableConfig) -> dict[str, Any]:
+        if harness_run is not None:
+            harness_run.before_model()
+        return {"messages": [bound_model.invoke(model_input(state), config=config)]}
+
+    async def arespond(state: AgentState, config: RunnableConfig) -> dict[str, Any]:
+        if harness_run is not None:
+            harness_run.before_model()
+        return {"messages": [await bound_model.ainvoke(model_input(state), config=config)]}
+
+    builder = StateGraph(AgentState)
+    builder.add_node("normalize", _prepare_input)
+    builder.add_node(
+        "agent", RunnableLambda(respond, afunc=arespond),
+        metadata={"dependencies": {"llm_config": [config_path]}},
+    )
+    builder.add_edge(START, "normalize")
+    if harness is not None and harness.planning.mode != "off":
+        planning_model = model.bind(response_format={"type": "json_object"})
+        def plan(state: AgentState, config: RunnableConfig) -> dict[str, Any]:
+            if harness_run is not None:
+                harness_run.before_model()
+            prompt = planning_messages(state["messages"], harness.planning)
+            if harness_run is not None:
+                prompt = harness_run.fit_context(prompt)
+            decision = parse_plan(planning_model.invoke(prompt, config=config), harness.planning, harness_run)
+            return {"plan": decision.steps, "plan_reason": decision.reason}
+
+        async def aplan(state: AgentState, config: RunnableConfig) -> dict[str, Any]:
+            if harness_run is not None:
+                harness_run.before_model()
+            prompt = planning_messages(state["messages"], harness.planning)
+            if harness_run is not None:
+                prompt = harness_run.fit_context(prompt)
+            decision = parse_plan(await planning_model.ainvoke(prompt, config=config), harness.planning, harness_run)
+            return {"plan": decision.steps, "plan_reason": decision.reason}
+
+        builder.add_node("plan", RunnableLambda(plan, afunc=aplan))
+        builder.add_edge("normalize", "plan")
+        builder.add_edge("plan", "agent")
+    else:
+        builder.add_edge("normalize", "agent")
+    if registered:
+        if harness_run is not None:
+            def check_tool(request: Any, execute: Any) -> Any:
+                if harness is not None and request.tool_call["name"] in harness.tool_policy.require_approval:
+                    raise RuntimeError("Approval tools require asynchronous execution")
+                harness_run.before_tool(request.tool_call["name"])
+                result = execute(request)
+                harness_run.record_tool_result(
+                    request.tool_call["name"], request.tool_call["id"],
+                    result.status if isinstance(result, ToolMessage) else "completed",
+                )
+                return result
+
+            async def acheck_tool(request: Any, execute: Any) -> Any:
+                if harness is not None and request.tool_call["name"] in harness.tool_policy.require_approval:
+                    assert approvals is not None and ctx is not None
+                    remaining = harness.execution.max_duration_seconds - (time.monotonic() - harness_run.started)
+                    approved = await approvals.require(ctx, request.tool_call, max(0, remaining))
+                    if not approved:
+                        harness_run.record_tool_result(request.tool_call["name"], request.tool_call["id"], "denied")
+                        return ToolMessage(
+                            content="User denied this tool call; it was not executed.",
+                            name=request.tool_call["name"], tool_call_id=request.tool_call["id"], status="error",
+                        )
+                harness_run.before_tool(request.tool_call["name"])
+                result = await execute(request)
+                harness_run.record_tool_result(
+                    request.tool_call["name"], request.tool_call["id"],
+                    result.status if isinstance(result, ToolMessage) else "completed",
+                )
+                return result
+
+            def handle_tool_error(exc: Exception) -> str:
+                if isinstance(exc, HarnessLimitError):
+                    raise exc
+                return str(exc)
+
+            node = ToolNode(
+                registered, handle_tool_errors=handle_tool_error,
+                wrap_tool_call=check_tool, awrap_tool_call=acheck_tool,
+            )
+        else:
+            node = ToolNode(registered, handle_tool_errors=True)
+        builder.add_node("tools", node)
+        builder.add_edge("tools", "agent")
+
+    if harness is not None and harness.verification.mode != "off":
+        def verify(state: AgentState) -> dict[str, Any]:
+            reason = (
+                verifier(state["messages"]) if harness.verification.mode == "project" and verifier is not None
+                else verify_tool_evidence(state["messages"])
+            )
+            if harness_run is not None:
+                harness_run.events.append({"type": "verification", "passed": reason is None, "reason": reason})
+            if reason is None:
+                return {"verification_issue": None}
+            attempts = state.get("repair_attempts", 0)
+            if attempts >= harness.verification.max_repair_attempts:
+                raise HarnessVerificationError(reason)
+            return {
+                "verification_issue": reason,
+                "repair_attempts": attempts + 1,
+                "messages": [HumanMessage(content=f"Verification failed: {reason}. Correct the result and answer again.")],
+            }
+
+        builder.add_node("verify", verify)
+        if registered:
+            builder.add_conditional_edges("agent", lambda state: "tools" if getattr(state["messages"][-1], "tool_calls", None) else "verify")
+        else:
+            builder.add_edge("agent", "verify")
+        builder.add_conditional_edges("verify", lambda state: "agent" if state.get("verification_issue") else END)
+    elif registered:
+        builder.add_conditional_edges("agent", tools_condition)
+    else:
+        builder.add_edge("agent", END)
+    return builder.compile(checkpointer=checkpointer)

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

@@ -23,6 +23,7 @@ from .event_subscriptions import EventSubscriptions
 from .graph_loader import is_agent_project
 from .openai import OpenAIChatHandler
 from .service import GraphService
+from .session_files import session_user_id
 from .stream_runner import RunOpt, agent_stream_handler, workflow_stream_handler
 from .trace_records import clear_run_records, get_run_record, list_run_records
 
@@ -49,6 +50,7 @@ def create_app(service: GraphService | None = None) -> FastAPI:
     runtime_service = service or GraphService()
     openai_handler = OpenAIChatHandler(runtime_service)
     subscriptions = EventSubscriptions(runtime_service)
+    interactive_runs: dict[str, tuple[asyncio.Task, str, float]] = {}
 
     @asynccontextmanager
     async def lifespan(app: FastAPI):
@@ -77,6 +79,10 @@ def create_app(service: GraphService | None = None) -> FastAPI:
         return JSONResponse(status_code=exc.status_code, content=exc.response_body())
 
     def register_task(run_id: str, task: asyncio.Task) -> None:
+        active = runtime_service.running_tasks.get(run_id)
+        if active is not None and not active.done():
+            task.cancel()
+            raise ValueError(f"run_id is already active: {run_id}")
         runtime_service.running_tasks[run_id] = task
 
     @app.get("/agent/subscriptions")
@@ -142,7 +148,31 @@ def create_app(service: GraphService | None = None) -> FastAPI:
                 owner_org_id=ctx.identity.owner_org_id,
                 workspace_id=ctx.identity.workspace_id,
             )
-            result = await runtime_service.run_with_timeout(payload, ctx)
+            if is_agent_project():
+                watch = runtime_service.approvals.watch(ctx.run_id)
+                execution = asyncio.create_task(runtime_service.run_with_timeout(payload, ctx))
+                watch_task = asyncio.create_task(watch.wait())
+                try:
+                    await asyncio.wait({execution, watch_task}, return_when=asyncio.FIRST_COMPLETED)
+                    if execution.done():
+                        result = await execution
+                    else:
+                        user_id = session_user_id(ctx)
+                        interactive_runs[ctx.run_id] = (execution, user_id, time.monotonic())
+                        for old_run_id, (old_task, _, started) in list(interactive_runs.items()):
+                            if old_task.done() and time.monotonic() - started > 3600:
+                                del interactive_runs[old_run_id]
+                        status_code = 202
+                        return JSONResponse(status_code=202, content={
+                            "status": "pending_approval",
+                            "run_id": ctx.run_id,
+                            "pending": runtime_service.approvals.list_for(ctx, ctx.run_id),
+                        })
+                finally:
+                    watch_task.cancel()
+                    runtime_service.approvals.unwatch(ctx.run_id)
+            else:
+                result = await runtime_service.run_with_timeout(payload, ctx)
             if isinstance(result, dict) and result.get("status") == "timeout":
                 status_code = 504
                 error_code = "TIMEOUT"
@@ -263,7 +293,56 @@ def create_app(service: GraphService | None = None) -> FastAPI:
     async def http_cancel(run_id: str, request: Request) -> dict[str, Any]:
         ctx = new_context(method="cancel", headers=request.headers)
         request_context.set(ctx)
-        return runtime_service.cancel_run(run_id, ctx)
+        try:
+            return runtime_service.cancel_run(run_id, ctx)
+        except ValueError as exc:
+            raise HTTPException(status_code=401, detail=str(exc)) from exc
+        except PermissionError as exc:
+            raise HTTPException(status_code=403, detail=str(exc)) from exc
+
+    @app.get("/agent/approvals/{run_id}")
+    async def agent_approvals(run_id: str, request: Request) -> dict[str, Any]:
+        ctx = new_context(method="approval_list", headers=request.headers)
+        try:
+            return {"pending": runtime_service.approvals.list_for(ctx, run_id)}
+        except ValueError as exc:
+            raise HTTPException(status_code=401, detail=str(exc)) from exc
+
+    @app.get("/agent/runs/{run_id}")
+    async def agent_run_result(run_id: str, request: Request) -> dict[str, Any]:
+        ctx = new_context(method="agent_run_result", headers=request.headers)
+        entry = interactive_runs.get(run_id)
+        if entry is None:
+            raise HTTPException(status_code=404, detail="Interactive run not found")
+        execution, owner_id, _ = entry
+        if session_user_id(ctx) != owner_id:
+            raise HTTPException(status_code=403, detail="Run belongs to another user")
+        if not execution.done():
+            return {"status": "running", "run_id": run_id}
+        try:
+            result = execution.result()
+            if isinstance(result, dict) and result.get("status") == "timeout":
+                return {"status": "timeout", "run_id": run_id, "message": result["message"]}
+            return {"status": "completed", "run_id": run_id, "result": result}
+        except asyncio.CancelledError:
+            return {"status": "cancelled", "run_id": run_id}
+        except Exception as exc:
+            return {"status": "error", "run_id": run_id, "error": str(exc)}
+
+    @app.post("/agent/approvals/{run_id}/{tool_call_id}")
+    async def decide_agent_approval(run_id: str, tool_call_id: str, request: Request) -> dict[str, Any]:
+        ctx = new_context(method="approval_decide", headers=request.headers)
+        body = await request.json()
+        if not isinstance(body, dict) or not isinstance(body.get("approved"), bool):
+            raise HTTPException(status_code=400, detail="approved must be a boolean")
+        try:
+            return runtime_service.approvals.decide(ctx, run_id, tool_call_id, body["approved"])
+        except KeyError as exc:
+            raise HTTPException(status_code=404, detail=str(exc)) from exc
+        except PermissionError as exc:
+            raise HTTPException(status_code=403, detail=str(exc)) from exc
+        except ValueError as exc:
+            raise HTTPException(status_code=409, detail=str(exc)) from exc
 
     @app.post("/node_run/{node_id}")
     async def http_node_run(node_id: str, request: Request) -> Any:
@@ -390,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.2/src/licos_agent_runtime/harness_approval.py

@@ -0,0 +1,138 @@
+"""One-use, authenticated, process-local tool decisions."""
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+import time
+from typing import Any
+
+from .context import Context
+from .session_files import session_user_id
+
+
+@dataclass(slots=True)
+class PendingApproval:
+    run_id: str
+    session_id: str
+    tool_call_id: str
+    user_id: str
+    tool_name: str
+    created: float
+    future: asyncio.Future[bool]
+    event_queue: asyncio.Queue[Any] | None
+    harness_run: Any | None
+
+    def public(self) -> dict[str, Any]:
+        return {
+            "run_id": self.run_id,
+            "session_id": self.session_id,
+            "tool_call_id": self.tool_call_id,
+            "tool_name": self.tool_name,
+            "created_monotonic": self.created,
+        }
+
+
+class ApprovalRegistry:
+    def __init__(self) -> None:
+        self._pending: dict[tuple[str, str], PendingApproval] = {}
+        self._decided: dict[tuple[str, str], bool] = {}
+        self._watches: dict[str, asyncio.Event] = {}
+
+    def watch(self, run_id: str) -> asyncio.Event:
+        event = asyncio.Event()
+        self._watches[run_id] = event
+        return event
+
+    def unwatch(self, run_id: str) -> None:
+        self._watches.pop(run_id, None)
+
+    async def require(self, ctx: Context, tool_call: dict[str, Any], timeout: float) -> bool:
+        user_id = session_user_id(ctx)
+        tool_call_id = str(tool_call["id"])
+        key = (ctx.run_id, tool_call_id)
+        if key in self._pending or key in self._decided:
+            raise ValueError(f"Tool call was already submitted for approval: {tool_call_id}")
+        queue = ctx.metadata.get("agent_event_queue")
+        pending = PendingApproval(
+            run_id=ctx.run_id,
+            session_id=str(ctx.metadata.get("session_id") or ctx.run_id),
+            tool_call_id=tool_call_id,
+            user_id=user_id,
+            tool_name=str(tool_call["name"]),
+            created=time.monotonic(),
+            future=asyncio.get_running_loop().create_future(),
+            event_queue=queue,
+            harness_run=ctx.metadata.get("agent_harness_run"),
+        )
+        if pending.harness_run is not None:
+            pending.harness_run.events.append({"type": "approval_required", "tool_call_id": tool_call_id,
+                                               "tool_name": pending.tool_name})
+        self._pending[key] = pending
+        watch = self._watches.get(ctx.run_id)
+        if watch is not None:
+            watch.set()
+        if queue is not None:
+            event = {
+                "type": "approval_required",
+                "run_id": pending.run_id,
+                "session_id": pending.session_id,
+                "tool_call_id": tool_call_id,
+                "tool_name": pending.tool_name,
+                "input": tool_call.get("args", {}),
+            }
+            queue.put_nowait({**event, "content": event})
+        try:
+            return await asyncio.wait_for(pending.future, timeout=timeout)
+        except asyncio.TimeoutError:
+            if pending.harness_run is not None:
+                pending.harness_run.events.append({"type": "approval_timeout", "tool_call_id": tool_call_id})
+            raise
+        except asyncio.CancelledError:
+            if pending.harness_run is not None:
+                pending.harness_run.events.append({"type": "approval_cancelled", "tool_call_id": tool_call_id})
+            raise
+        finally:
+            self._pending.pop(key, None)
+            self._decided.setdefault(key, False)
+
+    def decide(self, ctx: Context, run_id: str, tool_call_id: str, approved: bool) -> dict[str, Any]:
+        pending = self._pending.get((run_id, tool_call_id))
+        if pending is None:
+            if (run_id, tool_call_id) in self._decided:
+                raise ValueError("Approval was already decided")
+            raise KeyError("Approval request is absent or already decided")
+        if pending.user_id != session_user_id(ctx):
+            raise PermissionError("Only the requesting user may decide this tool call")
+        if pending.future.done():
+            raise ValueError("Approval was already decided")
+        pending.future.set_result(approved)
+        self._decided[(run_id, tool_call_id)] = approved
+        if pending.harness_run is not None:
+            pending.harness_run.events.append({"type": "approval_decision", "tool_call_id": tool_call_id,
+                                               "approved": approved})
+        if pending.event_queue is not None:
+            event = {
+                "type": "approval_response",
+                "run_id": run_id,
+                "session_id": pending.session_id,
+                "tool_call_id": tool_call_id,
+                "approved": approved,
+            }
+            pending.event_queue.put_nowait({**event, "content": event})
+        return {"run_id": run_id, "tool_call_id": tool_call_id, "approved": approved}
+
+    def list_for(self, ctx: Context, run_id: str) -> list[dict[str, Any]]:
+        user_id = session_user_id(ctx)
+        return [
+            pending.public() for (current_run_id, _), pending in self._pending.items()
+            if current_run_id == run_id and pending.user_id == user_id and not pending.future.done()
+        ]
+
+    def forget_run(self, run_id: str) -> None:
+        for key, pending in list(self._pending.items()):
+            if key[0] == run_id:
+                if not pending.future.done():
+                    pending.future.cancel()
+                del self._pending[key]
+        for key in [key for key in self._decided if key[0] == run_id]:
+            del self._decided[key]