agentlisp 2.0.0__py3-none-any.whl

host/workflow_temporal.py

@@ -0,0 +1,89 @@
+"""
+AgentLisp v2.0 Temporal 长流程与人在回路 (HITL) 引擎 (host/workflow_temporal.py)
+符合 IF-TEMPORAL-1 规约：
+利用 Temporal 实现长流程挂起落盘与人在回路 Signal 唤醒审批机制。
+"""
+
+import logging
+from datetime import timedelta
+from typing import Any
+
+try:
+    from temporalio import activity, workflow
+    from temporalio.client import Client
+
+    TEMPORAL_AVAILABLE = True
+except ImportError:
+    TEMPORAL_AVAILABLE = False
+
+logger = logging.getLogger("AgentLisp.TemporalEngine")
+
+
+class AgentLispTemporalEngine:
+    def __init__(self, temporal_host: str = "localhost:7233"):
+        self.temporal_host = temporal_host
+        self.client: Any | None = None
+
+    async def connect(self):
+        if not TEMPORAL_AVAILABLE:
+            logger.info("ℹ️ Temporal SDK 未安装，将使用 DirectRunner 本地非持久化运行。")
+            return
+        try:
+            self.client = await Client.connect(self.temporal_host)
+            logger.info(f"✅ 已成功连接 Temporal 长流程服务端 -> {self.temporal_host}")
+        except Exception as e:
+            logger.warning(f"⚠️ 无法连接 Temporal 服务端 ({e})，降级为本地内存调度。")
+
+
+if TEMPORAL_AVAILABLE:
+
+    @activity.defn(name="agentlisp_execute_tool_activity")
+    async def execute_tool_activity(params: dict[str, Any]) -> dict[str, Any]:
+        """Temporal Activity：执行受 Harness 门控保护的工具动作"""
+        tool_name = params.get("tool_name")
+        cmd = params.get("args", {}).get("command", "")
+        logger.info(f"⚡ [Temporal Activity] 正在执行工具: {tool_name} ({cmd})")
+        return {"exit_code": 0, "stdout": f"Executed {cmd} successfully under Temporal Activity."}
+
+    @workflow.defn(name="AgentLispHITLWorkflow")
+    class AgentLispHITLWorkflow:
+        def __init__(self):
+            self.approval_signal_received = False
+            self.approval_decision = "PENDING"
+
+        @workflow.signal(name="approve_tool_execution")
+        def receive_approval_signal(self, decision: str):
+            """接收运维/人类审批人员发来的 Approve / Reject 信号"""
+            self.approval_signal_received = True
+            self.approval_decision = decision
+
+        @workflow.run
+        async def run(self, agent_request: dict[str, Any]) -> dict[str, Any]:
+            tool_name = agent_request.get("tool_name", "git-push")
+            requires_approval = agent_request.get("requires_approval", True)
+
+            if requires_approval:
+                logger.info(
+                    f"⏸ [Temporal HITL 挂起] 工具 '{tool_name}' 需要人类审批，等待 Signal 唤醒..."
+                )
+                # 栈帧挂起落盘，绝不占用物理内存和线程
+                await workflow.wait_condition(lambda: self.approval_signal_received)
+
+                if self.approval_decision != "APPROVED":
+                    logger.warning(f"❌ [Temporal HITL 拒绝] 审批结果: {self.approval_decision}")
+                    return {"status": "rejected", "reason": "Human reviewer rejected execution."}
+
+            logger.info("▶ [Temporal HITL 恢复] 审批通过，继续执行 Activity...")
+            # temporalio 1.x 要求所有 timeout 必须是 datetime.timedelta（不能是 float/None 且不能写成 deadline float），
+            # 否则 protobuf well_known_types.FromTimedelta 会报 AttributeError float has no attribute 'seconds'
+            res = await workflow.execute_activity(
+                execute_tool_activity,
+                agent_request,
+                start_to_close_timeout=timedelta(seconds=60),
+            )
+            return {"status": "success", "result": res}
+
+
+if __name__ == "__main__":
+    print("=== 测试 AgentLisp Temporal 模版加载 ===")
+    print(f"Temporal SDK 可用性: {TEMPORAL_AVAILABLE}")

runtime/__init__.py

@@ -0,0 +1,29 @@
+"""Runtime public API."""
+
+from __future__ import annotations
+
+from .base_harness import (
+    BaseHarness,
+    ExecutionTrace,
+    ReActTurn,
+)
+from .errors import (
+    AgentLispError,
+    CheckpointError,
+    FeatureNotInstalledError,
+    HarnessError,
+    ToolNotFoundError,
+)
+
+__version__ = "2.0.0"
+__all__ = [
+    "AgentLispError",
+    "BaseHarness",
+    "CheckpointError",
+    "ExecutionTrace",
+    "FeatureNotInstalledError",
+    "HarnessError",
+    "ReActTurn",
+    "ToolNotFoundError",
+    "__version__",
+]

runtime/base_agent_harness.py

@@ -0,0 +1,164 @@
+"""
+AgentLisp v2.0 核心运行时基类 (runtime/base_agent_harness.py)
+固化架构规范：
+1. KV Cache 严格前缀对齐 (Static System Prompt -> Static Tools -> Trajectory -> Status Bar)
+2. Harness 三重控制流管道 (Constrain -> Execute -> Verify -> Correct)
+"""
+
+import asyncio
+import logging
+from typing import Any
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - [%(levelname)s] - %(message)s")
+
+
+class BaseAgentHarness:
+    def __init__(
+        self,
+        model_config: dict[str, Any],
+        context_config: dict[str, Any],
+        tools_config: dict[str, Any],
+        harness_config: dict[str, Any],
+    ):
+        self.model_config = model_config
+        self.context_config = context_config
+        self.tools_config = tools_config
+        self.harness_config = harness_config
+
+        # 运行时状态
+        self.trajectory: list[dict[str, Any]] = []
+        self.step_count: int = 0
+        self.is_terminated: bool = False
+
+    # ------------------------------------------------------------------
+    # 1. KV Cache 对齐的上下文组装器 (Static -> Dynamic -> Trailing Hook)
+    # ------------------------------------------------------------------
+    def build_context(self) -> list[dict[str, Any]]:
+        """
+        严格按照 AgentLisp 规约组装 Context：
+        [1. System Prompt (Static)] -> [2. Tool Schemas (Static)]
+        -> [3. History Trajectory (Dynamic)] -> [4. Status Bar (Trailing Hook)]
+        """
+        messages = []
+
+        # (1) 静态 System Prompt
+        sys_prompt = self.model_config.get("system_prompt", "You are a helpful Agent.")
+        messages.append({"role": "system", "content": sys_prompt})
+
+        # (2) 静态工具声明 (有助于 LLM 供应商进行 Prefix Caching)
+        if "tools_schema" in self.tools_config:
+            messages.append(
+                {
+                    "role": "system",
+                    "content": f"<tools_definition>\n{self.tools_config['tools_schema']}\n</tools_definition>",
+                }
+            )
+
+        # (3) 动态历史轨迹 (Trajectory)
+        messages.extend(self.trajectory)
+
+        # (4) 尾部 Status Bar 挂钩 (防止模型长对话迷失)
+        status_items = self.context_config.get("status_bar", {})
+        if status_items.get("step_count", True):
+            status_bar_str = (
+                f"<agent_status>Step: {self.step_count} | Status: Active</agent_status>"
+            )
+            messages.append({"role": "user", "content": status_bar_str})
+
+        return messages
+
+    # ------------------------------------------------------------------
+    # 2. Harness 三重安全与控制流管道
+    # ------------------------------------------------------------------
+    def constrain(self, tool_call: dict[str, Any]) -> tuple[bool, str]:
+        """【护栏 1：约束 (Constrain)】负面清单与工作区安全锁"""
+        cmd = tool_call.get("args", {}).get("command", "")
+        forbidden_list = self.harness_config.get("constrain", {}).get("forbidden_commands", [])
+
+        for forbidden in forbidden_list:
+            if forbidden in cmd:
+                logging.warning(f"❌ [Constrain 拦截] 触发禁用命令: {forbidden}")
+                return False, f"Harness Blocked: Execution of '{forbidden}' is strictly forbidden."
+
+        return True, "OK"
+
+    def verify(self, observation: dict[str, Any]) -> tuple[bool, str]:
+        """【护栏 2：验证 (Verify)】结果静态/动态断言"""
+        # 如果观察结果中存在语法/Linter 错误
+        if observation.get("exit_code", 0) != 0:
+            err_msg = observation.get("stderr", "Execution failed")
+            logging.warning(f"⚠️️ [Verify 失败] 输出断言不通过: {err_msg}")
+            return False, err_msg
+
+        return True, "Verified"
+
+    async def correct(
+        self, tool_call: dict[str, Any], error_msg: str, retries: int
+    ) -> dict[str, Any]:
+        """【护栏 3：纠正 (Correct)】局部静默重试与降级"""
+        max_retries = self.harness_config.get("correct", {}).get("max_retries", 3)
+        logging.info(f"🔄 [Correct 自动纠错] 第 {retries}/{max_retries} 次重试...")
+
+        if retries >= max_retries:
+            on_failure = self.harness_config.get("correct", {}).get("on_failure", "ask_human")
+            logging.error(f"🚨 [Correct 熔断] 已达最大重试上限，触发终态策略: {on_failure}")
+            return {"status": "failed", "action": on_failure, "error": error_msg}
+
+        # 内部静默重试逻辑（可返回反馈提示给模型）
+        return {
+            "status": "retry",
+            "feedback": f"Previous execution failed with: {error_msg}. Please fix your parameters.",
+        }
+
+    # ------------------------------------------------------------------
+    # 3. 核心 ReAct 步骤驱动循环
+    # ------------------------------------------------------------------
+    async def step(self, user_input: str | None = None) -> dict[str, Any]:
+        self.step_count += 1
+        if user_input:
+            self.trajectory.append({"role": "user", "content": user_input})
+
+        context = self.build_context()
+        logging.info(f"🚀 [Step {self.step_count}] 上下文组装完毕，消息数: {len(context)}")
+
+        # 模拟模型决策与工具调用（实际运行时替换为真实的 LLM API 调用）
+        mock_tool_call = {"tool_name": "bash", "args": {"command": "ls -la"}}
+
+        # 运行 Harness 管道
+        allowed, reason = self.constrain(mock_tool_call)
+        if not allowed:
+            self.trajectory.append({"role": "tool", "content": reason})
+            return {"status": "blocked", "reason": reason}
+
+        # 模拟执行工具
+        mock_observation = {"exit_code": 0, "stdout": "file1.py\nfile2.py", "stderr": ""}
+
+        passed, verify_msg = self.verify(mock_observation)
+        if not passed:
+            correction = await self.correct(mock_tool_call, verify_msg, retries=1)
+            return correction
+
+        self.trajectory.append({"role": "tool", "content": mock_observation["stdout"]})
+        return {"status": "success", "output": mock_observation["stdout"]}
+
+
+# ----------------------------------------------------------------------
+# 本地验证：单文件可直接运行测试
+# ----------------------------------------------------------------------
+if __name__ == "__main__":
+    print("=== 测试 AgentLisp BaseAgentHarness 运行时 ===")
+
+    # 初始化配置
+    agent_harness = BaseAgentHarness(
+        model_config={"system_prompt": "你是一个自动修复 Bug 的 Agent。"},
+        context_config={"status_bar": {"step_count": True}},
+        tools_config={"tools_schema": "Tool: bash(command: str)"},
+        harness_config={
+            "constrain": {"forbidden_commands": ["rm -rf"]},
+            "correct": {"max_retries": 3, "on_failure": "ask_human"},
+        },
+    )
+
+    # 运行一步测试
+    asyncio.run(agent_harness.step("请检查当前目录下的文件"))
+    print("✅ BaseAgentHarness 运行成功！")

runtime/base_harness.py

@@ -0,0 +1,359 @@
+"""AgentLisp v2 BaseHarness ReAct loop & pipeline skeleton."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+import uuid
+from collections.abc import AsyncIterable, Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+import structlog
+from pydantic import BaseModel, Field
+
+from .errors import HarnessError, ToolNotFoundError
+
+log = structlog.get_logger()
+
+
+@dataclass
+class ReActTurn:
+    index: int
+    thought: str = ""
+    action_name: str = ""
+    action_input: dict[str, Any] = field(default_factory=dict)
+    observation: Any = None
+    answer: str = ""
+    started_at: float = field(default_factory=time.perf_counter)
+    finished_at: float | None = None
+
+    def finish(self) -> None:
+        self.finished_at = time.perf_counter()
+
+    @property
+    def duration_ms(self) -> float:
+        end = self.finished_at if self.finished_at is not None else time.perf_counter()
+        return (end - self.started_at) * 1000.0
+
+
+class ExecutionTrace(BaseModel):
+    run_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    agent_name: str = ""
+    turns: list[dict[str, Any]] = Field(default_factory=list)
+    final_answer: str = ""
+    status: str = "pending"
+    started_at: float = Field(default_factory=time.perf_counter)
+    finished_at: float | None = None
+    error: str | None = None
+
+    @property
+    def duration_ms(self) -> float:
+        end = self.finished_at if self.finished_at is not None else time.perf_counter()
+        return (end - self.started_at) * 1000.0
+
+
+class BaseHarness:
+    """ReAct 循环 + Harness 管道基类。
+
+    设计目标：
+      1. 完全无外部依赖也能跑（通过 MockLLM / NullTool / MemoryCheckpoint）；
+      2. Compiler 输出直接继承此类；
+      3. 支持 run / run_async / stream_async 三种调用方式；
+      4. 每次调用生成一条 ExecutionTrace（证据链）。
+    """
+
+    agent_name: str = ""
+
+    def __init__(
+        self,
+        agent_cfg: dict[str, Any] | None = None,
+        llm_client: Any | None = None,
+        tool_registry: Any | None = None,
+        checkpoint_store: Any | None = None,
+        memory_fs: Any | None = None,
+        status_bar: Any | None = None,
+        max_turns: int = 30,
+        react_mode: bool = True,
+    ) -> None:
+        self.cfg = agent_cfg or {}
+        self.agent_name = self.agent_name or str(self.cfg.get("name", "unnamed-agent"))
+        self.llm = llm_client or _NullLLM()
+        self.tools = tool_registry or _NullToolRegistry()
+        self.checkpoint = checkpoint_store or _MemoryCheckpoint()
+        self.memory = memory_fs or _NullMemoryFS()
+        self.status_bar = status_bar or _NullStatusBar()
+        self.max_turns = int(max_turns)
+        self.react_mode = bool(react_mode)
+        self._hooks: dict[str, list[Callable[..., Any]]] = {}
+
+    # ------------------------------------------------------------------ hooks
+    def on(self, event: str, cb: Callable[..., Any]) -> None:
+        self._hooks.setdefault(event, []).append(cb)
+
+    def _emit(self, event: str, payload: dict[str, Any]) -> None:
+        for cb in self._hooks.get(event, []):
+            try:
+                cb(payload)
+            except Exception:
+                log.exception("hook.failed", event=event)
+
+    # ------------------------------------------------------------- public API
+    def run(self, inputs: dict[str, Any] | None = None, **kwargs: Any) -> ExecutionTrace:
+        return asyncio.run(self.run_async(inputs=inputs, **kwargs))
+
+    async def run_async(
+        self,
+        inputs: dict[str, Any] | None = None,
+        workflow: str | None = None,
+    ) -> ExecutionTrace:
+        trace = ExecutionTrace(agent_name=self.agent_name)
+        try:
+            await self.status_bar.on_start(trace, inputs or {})
+            self._emit("start", {"run_id": trace.run_id, "inputs": inputs})
+            await self.checkpoint.save(trace.run_id, {"stage": "start", "inputs": inputs})
+
+            if workflow and (engine := self._legacy_engine()):
+                from agentlisp_runtime.models import ExecutionContext  # noqa: F401
+
+                result = await engine.run_workflow(
+                    workflow_name=workflow,
+                )
+                for step in result.steps:
+                    t = ReActTurn(
+                        index=len(trace.turns),
+                        action_name=f"step:{step.step_id}",
+                        action_input={"status": step.status.value},
+                        observation=step.output,
+                    )
+                    t.finish()
+                    trace.turns.append(_turn_to_dict(t))
+                trace.final_answer = _jsonable_snapshot(result)
+                trace.status = result.status.value
+            else:
+                await self._react_loop(trace, inputs or {})
+
+            trace.status = "success" if trace.status == "pending" else trace.status
+            self._emit("done", {"run_id": trace.run_id, "answer": trace.final_answer})
+            await self.status_bar.on_done(trace)
+        except Exception as exc:
+            trace.status = "failed"
+            trace.error = str(exc)
+            log.exception("harness.failed", run_id=trace.run_id, error=str(exc))
+            await self.status_bar.on_error(trace, exc)
+            self._emit("error", {"run_id": trace.run_id, "error": str(exc)})
+            raise HarnessError(f"run {trace.run_id} failed: {exc}") from exc
+        finally:
+            trace.finished_at = time.perf_counter()
+            await self.checkpoint.save(trace.run_id, {"trace": trace.model_dump(mode="json")})
+        return trace
+
+    async def stream_async(
+        self, inputs: dict[str, Any] | None = None, **_kw: Any
+    ) -> AsyncIterable[dict[str, Any]]:
+        q: asyncio.Queue[dict[str, Any]] = asyncio.Queue()
+
+        def _enqueue(payload: dict[str, Any]) -> None:
+            q.put_nowait(payload)
+
+        self.on("start", lambda p: _enqueue({"event": "start", **p}))
+        self.on("turn", lambda p: _enqueue({"event": "turn", **p}))
+        self.on("done", lambda p: _enqueue({"event": "done", **p}))
+        self.on("error", lambda p: _enqueue({"event": "error", **p}))
+
+        task = asyncio.create_task(self.run_async(inputs=inputs))
+
+        while not task.done() or not q.empty():
+            try:
+                item = await asyncio.wait_for(q.get(), timeout=0.1)
+                yield item
+            except TimeoutError:
+                continue
+        # drain remaining
+        while not q.empty():
+            yield q.get_nowait()
+        await task
+
+    # ------------------------------------------------------------- ReAct core
+    async def _react_loop(self, trace: ExecutionTrace, inputs: dict[str, Any]) -> None:
+        prompt_payload = {
+            "agent": self.agent_name,
+            "purpose": self.cfg.get("purpose", ""),
+            "tools": self.cfg.get("tools", []),
+            "workflows": self.cfg.get("workflows", []),
+            "inputs": inputs,
+        }
+        history: list[dict[str, Any]] = []
+
+        for idx in range(self.max_turns):
+            turn = ReActTurn(index=idx)
+            self._emit("turn", {"index": idx, "stage": "think"})
+            try:
+                response = await self.llm.next(prompt_payload, history, trace)
+            except Exception as exc:
+                raise HarnessError(f"LLM call failed at turn {idx}: {exc}") from exc
+
+            structured = self._coerce_llm_response(response)
+            turn.thought = structured.get("thought", "")
+            turn.action_name = structured.get("action", "")
+            turn.action_input = structured.get("action_input", {}) or {}
+
+            if structured.get("answer") or structured.get("final_answer"):
+                turn.answer = structured.get("answer") or structured.get("final_answer", "")
+                trace.final_answer = turn.answer
+                turn.finish()
+                trace.turns.append(_turn_to_dict(turn))
+                self._emit("turn", {"index": idx, "stage": "answer", "answer": turn.answer})
+                return
+
+            try:
+                obs = await self._dispatch_tool(turn.action_name, turn.action_input)
+            except ToolNotFoundError:
+                obs = {"error": f"tool not found: {turn.action_name}"}
+            turn.observation = obs
+            turn.finish()
+            history.append({"role": "assistant", **_turn_to_dict(turn)})
+            history.append({"role": "observation", "index": idx, "value": _jsonable_snapshot(obs)})
+            trace.turns.append(_turn_to_dict(turn))
+            await self.checkpoint.save(trace.run_id, {"turns": trace.turns})
+            await self.status_bar.on_step(trace, turn)
+            self._emit("turn", {"index": idx, "stage": "observed", "observation": obs})
+
+        raise HarnessError(f"ReAct exceeded max_turns={self.max_turns}")
+
+    @staticmethod
+    def _coerce_llm_response(raw: Any) -> dict[str, Any]:
+        if isinstance(raw, dict):
+            return raw
+        if isinstance(raw, str):
+            return {"thought": raw[:500]}
+        if hasattr(raw, "model_dump"):
+            return dict(raw.model_dump())  # type: ignore[attr-defined]
+        return {"thought": str(raw)[:500]}
+
+    async def _dispatch_tool(self, action_name: str, action_input: dict[str, Any]) -> Any:
+        if not action_name:
+            return {"skipped": True}
+        if hasattr(self.tools, "call"):
+            return await self.tools.call(action_name, **action_input)
+        if hasattr(self.tools, "get"):
+            fn = self.tools.get(action_name)
+            if callable(fn):
+                if asyncio.iscoroutinefunction(fn):
+                    return await fn(**action_input)
+                return fn(**action_input)
+        raise ToolNotFoundError(f"no handler for action: {action_name}")
+
+    # ----------------------------------------------------------- v0.1 bridge
+    def _legacy_engine(self) -> Any | None:
+        try:
+            from agentlisp_runtime.engine import AgentEngine
+            from agentlisp_runtime.loader import AgentLoader
+        except Exception:
+            return None
+        try:
+            agent = AgentLoader.from_dict(self.cfg)
+            handlers = {
+                k: v for k, v in (self.tools.handlers() if hasattr(self.tools, "handlers") else {})
+            }
+            return AgentEngine(agent, tool_handlers=handlers)
+        except Exception:
+            return None
+
+
+def _turn_to_dict(t: ReActTurn) -> dict[str, Any]:
+    return {
+        "index": t.index,
+        "thought": t.thought,
+        "action": t.action_name,
+        "action_input": t.action_input,
+        "observation": _jsonable_snapshot(t.observation),
+        "answer": t.answer,
+        "duration_ms": round(t.duration_ms, 3),
+    }
+
+
+def _jsonable_snapshot(v: Any) -> Any:
+    if isinstance(v, (str, int, float, bool)) or v is None:
+        return v
+    if isinstance(v, (list, tuple)):
+        return [_jsonable_snapshot(x) for x in v]
+    if isinstance(v, dict):
+        return {str(k): _jsonable_snapshot(val) for k, val in v.items()}
+    if hasattr(v, "model_dump"):
+        try:
+            return v.model_dump(mode="json")  # type: ignore[attr-defined]
+        except Exception:
+            return str(v)
+    return str(v)
+
+
+# ----------------------------------------------------------------- null impls
+class _NullLLM:
+    async def next(
+        self, prompt: dict[str, Any], history: list[dict[str, Any]], trace: ExecutionTrace
+    ) -> dict[str, Any]:
+        # 无 LLM 时默认：最多 1 个 answer 回合，终止
+        if any(t.get("answer") for t in trace.turns):
+            return {"answer": "<done>"}
+        return {
+            "thought": "MockLLM: no-op (install llm optional group for real LLM)",
+            "action": "",
+            "action_input": {},
+            "answer": f"finished (mock). inputs={prompt.get('inputs')}",
+        }
+
+
+class _NullToolRegistry:
+    def __init__(self) -> None:
+        self._handlers: dict[str, Callable[..., Any]] = {}
+
+    def register(self, name: str, fn: Callable[..., Any]) -> None:
+        self._handlers[name] = fn
+
+    def handlers(self) -> dict[str, Callable[..., Any]]:
+        return dict(self._handlers)
+
+    def get(self, name: str) -> Callable[..., Any] | None:
+        return self._handlers.get(name)
+
+    async def call(self, name: str, **kwargs: Any) -> Any:
+        fn = self._handlers.get(name)
+        if fn is None:
+            raise ToolNotFoundError(name)
+        if asyncio.iscoroutinefunction(fn):
+            return await fn(**kwargs)
+        return fn(**kwargs)
+
+
+class _MemoryCheckpoint:
+    def __init__(self) -> None:
+        self.store: dict[str, dict[str, Any]] = {}
+
+    async def save(self, run_id: str, snapshot: dict[str, Any]) -> None:
+        self.store.setdefault(run_id, {}).update(snapshot)
+
+    async def load(self, run_id: str) -> dict[str, Any] | None:
+        return self.store.get(run_id)
+
+
+class _NullMemoryFS:
+    async def read(self, path: str) -> str | None:
+        return None
+
+    async def write(self, path: str, content: str) -> None:
+        return None
+
+
+class _NullStatusBar:
+    async def on_start(self, trace: ExecutionTrace, inputs: dict[str, Any]) -> None:
+        log.debug("status.on_start", run_id=trace.run_id)
+
+    async def on_step(self, trace: ExecutionTrace, turn: ReActTurn) -> None:
+        log.debug("status.on_step", run_id=trace.run_id, turn=turn.index)
+
+    async def on_done(self, trace: ExecutionTrace) -> None:
+        log.debug("status.on_done", run_id=trace.run_id, status=trace.status)
+
+    async def on_error(self, trace: ExecutionTrace, exc: BaseException) -> None:
+        log.debug("status.on_error", run_id=trace.run_id, error=str(exc))