@baimingtao/lbs-agent 1.0.0

package/runtime/orchestration/loop/message_history.py

@@ -0,0 +1,71 @@
+"""Provider-aware conversation history owned outside AgentLoop."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+
+class MessageHistory:
+    """Owns message storage and provider-specific assistant/tool encoding."""
+
+    def __init__(self, api_mode: str = "", messages: list[dict[str, Any]] | None = None):
+        self.api_mode = api_mode
+        self.messages = list(messages or [])
+
+    def append_user(self, content: Any) -> None:
+        self.messages.append({"role": "user", "content": content})
+
+    def append_assistant(self, response) -> None:
+        if self.api_mode == "anthropic_messages":
+            content = []
+            if response.content:
+                content.append({"type": "text", "text": response.content})
+            for call in response.tool_calls:
+                content.append({
+                    "type": "tool_use",
+                    "id": call.id,
+                    "name": call.name,
+                    "input": call.arguments,
+                })
+            self.messages.append({"role": "assistant", "content": content})
+            return
+
+        message: dict[str, Any] = {
+            "role": "assistant",
+            "content": response.content or None,
+        }
+        if response.has_tool_calls:
+            message["tool_calls"] = [
+                {
+                    "id": call.id,
+                    "type": "function",
+                    "function": {
+                        "name": call.name,
+                        "arguments": json.dumps(call.arguments, ensure_ascii=False),
+                    },
+                }
+                for call in response.tool_calls
+            ]
+        self.messages.append(message)
+
+    def append_tool_result(self, call, record) -> None:
+        content = record.result[:8000]
+        if self.api_mode == "anthropic_messages":
+            self.messages.append({
+                "role": "user",
+                "content": [{
+                    "type": "tool_result",
+                    "tool_use_id": call.id,
+                    "content": content,
+                }],
+            })
+            return
+        self.messages.append({
+            "role": "tool",
+            "tool_call_id": call.id,
+            "content": content,
+        })
+
+    def replace(self, messages: list[dict[str, Any]]) -> None:
+        self.messages = [dict(message) for message in messages]

package/runtime/orchestration/loop/progress_tracker.py

@@ -0,0 +1,211 @@
+"""
+ProgressTracker — 结构化进展追踪器。
+
+替代纯字符串签名的 stall 检测。
+
+设计：
+  多维度进展信号：
+    1. 新工具调用（之前没调过的工具）
+    2. 新文件路径（read_file/write_file/patch 引入了新路径）
+    3. 新命令（terminal 命令不同）
+    4. 工具结果内容变化（同工具同参数但结果不同）
+    5. 工具成功 vs 失败
+    6. 文本回复内容变化
+
+  连续 N 轮无任何进展信号 -> stall
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class StallAssessment:
+    """一次 stall 评估的结果。"""
+    stalled: bool
+    stall_count: int
+    reason: str
+    signals: list[str] = field(default_factory=list)
+    progress_hash: str = ""
+    file_revisits: int = 0  # 本轮中对已访问文件的重复读取次数
+    revisited_files: list[str] = field(default_factory=list)  # 本轮重复访问的文件路径
+
+
+class ProgressTracker:
+    """追踪每轮迭代的进展信号。
+
+    比纯字符串签名更可靠：
+    - 不只看工具名+参数，还看结果内容 hash
+    - 不只看文本前 300 字，看整段内容的 hash
+    - 区分"做了事但没进展"和"完全没做事"
+    - 连续 N 轮无新信号才判 stall（容忍一轮重试）
+    """
+
+    def __init__(self, stall_threshold: int = 2):
+        self.stall_threshold = stall_threshold
+        self._consecutive_stall = 0
+        self._seen_file_paths: set[str] = set()
+        self._seen_commands: set[str] = set()
+        self._seen_tool_names: set[str] = set()
+        self._last_result_hashes: dict[str, str] = {}
+        self._last_text_hash: str = ""
+        self._last_progress_hash: str = ""
+
+    def assess(self, step) -> StallAssessment:
+        """评估一步迭代是否有进展。"""
+        signals: list[str] = []
+        progress_hash_input = ""
+
+        has_tool_execs = bool(getattr(step, "tool_execs", None))
+
+        if has_tool_execs:
+            _round_revisits = 0
+            _round_revisited_files = []
+            for te in step.tool_execs:
+                name = te.name or ""
+                args = te.args or {}
+                result = te.result or ""
+                success = te.success
+
+                if name and name not in self._seen_tool_names:
+                    self._seen_tool_names.add(name)
+                    signals.append(f"new_tool:{name}")
+
+                fp = self._extract_file_path(name, args)
+                if fp:
+                    normalized_fp = self._normalize_path(fp)
+                    if normalized_fp not in self._seen_file_paths:
+                        self._seen_file_paths.add(normalized_fp)
+                        signals.append(f"new_file:{fp}")
+                    else:
+                        # 文件已访问过 — 这是 revisit
+                        _round_revisits += 1
+                        _round_revisited_files.append(fp)
+                        signals.append(f"file_revisit:{fp}")
+
+                cmd = self._extract_command(name, args)
+                if cmd and cmd not in self._seen_commands:
+                    self._seen_commands.add(cmd)
+                    signals.append(f"new_cmd:{cmd}")
+
+                args_key = self._args_key(name, args)
+                result_hash = self._hash(result)
+                if args_key in self._last_result_hashes:
+                    if self._last_result_hashes[args_key] != result_hash:
+                        signals.append(f"result_changed:{name}")
+                self._last_result_hashes[args_key] = result_hash
+
+                if success:
+                    signals.append(f"tool_success:{name}")
+
+                progress_hash_input += f"{name}:{args_key}:{result_hash}:{success}|"
+
+                if name == "todo" and all(t.name == "todo" for t in step.tool_execs):
+                    signals.append("only_todo")
+
+                if not success:
+                    signals.append(f"tool_failed:{name}")
+        else:
+            text = (getattr(step, "llm_content", "") or "").strip()
+            text_hash = self._hash(text)
+            if text_hash != self._last_text_hash:
+                signals.append("text_changed")
+            self._last_text_hash = text_hash
+            progress_hash_input = f"text:{text_hash}"
+
+        real_progress = any(
+            s.startswith("new_") or s.startswith("result_changed") or s.startswith("text_changed")
+            for s in signals
+        )
+
+        current_hash = self._hash(progress_hash_input)
+
+        if real_progress:
+            self._consecutive_stall = 0
+        else:
+            self._consecutive_stall += 1
+
+        self._last_progress_hash = current_hash
+
+        reason = ""
+        if self._consecutive_stall >= self.stall_threshold:
+            if "only_todo" in signals:
+                reason = "连续多轮只调用 todo，未推进到实际工具。"
+            elif any("tool_failed" in s for s in signals):
+                failed = [s.split(":")[1] for s in signals if "tool_failed" in s]
+                reason = f"工具持续失败: {', '.join(failed)}。"
+            elif not has_tool_execs:
+                reason = "连续多轮无工具调用且文本回复未产生新进展。"
+            else:
+                reason = "连续重复相同工具+参数+结果，未产生新进展。"
+
+        stalled = self._consecutive_stall >= self.stall_threshold
+
+        return StallAssessment(
+            stalled=stalled,
+            stall_count=self._consecutive_stall,
+            reason=reason,
+            signals=signals,
+            progress_hash=current_hash,
+            file_revisits=_round_revisits if has_tool_execs else 0,
+            revisited_files=_round_revisited_files if has_tool_execs else [],
+        )
+
+    def reset(self):
+        """重置追踪器状态。"""
+        self._consecutive_stall = 0
+        self._seen_file_paths.clear()
+        self._seen_commands.clear()
+        self._seen_tool_names.clear()
+        self._last_result_hashes.clear()
+        self._last_text_hash = ""
+        self._last_progress_hash = ""
+
+    @staticmethod
+    def _normalize_path(path: str) -> str:
+        """规范化文件路径，使同文件不同写法（offset/limit/绝对相对）归一。
+
+        read_file(path=README.md, offset=1) 和 read_file(path=README.md, offset=20)
+        应该被识别为访问同一文件。
+        """
+        if not path:
+            return ""
+        import os as _os
+        # 统一路径分隔符 + 小写化（Windows 不区分大小写）
+        normalized = path.replace("\\", "/").lower()
+        # 只取路径部分（去掉 query 参数等），保留文件名
+        normalized = normalized.split("?")[0]
+        return normalized
+
+    @staticmethod
+    def _extract_file_path(tool_name: str, args: dict) -> str:
+        if not isinstance(args, dict):
+            return ""
+        for key in ("path", "file_path", "filepath", "file"):
+            val = args.get(key, "")
+            if val and isinstance(val, str):
+                return val
+        return ""
+
+    @staticmethod
+    def _extract_command(tool_name: str, args: dict) -> str:
+        if not isinstance(args, dict):
+            return ""
+        if tool_name in ("terminal", "bash", "shell"):
+            return str(args.get("command", ""))[:200]
+        return ""
+
+    @staticmethod
+    def _args_key(tool_name: str, args: dict) -> str:
+        try:
+            return f"{tool_name}:{json.dumps(args or {}, sort_keys=True, ensure_ascii=False)[:300]}"
+        except Exception:
+            return f"{tool_name}:{str(args)[:300]}"
+
+    @staticmethod
+    def _hash(text: str) -> str:
+        return hashlib.md5((text or "").encode("utf-8")).hexdigest()[:12]

package/runtime/orchestration/loop/run_trace.py

@@ -0,0 +1,70 @@
+"""RunTrace contract for AgentLoop phase-level observability."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any
+
+
+class LoopPhase(Enum):
+    START = "start"
+    CONTEXT_PREFLIGHT = "context_preflight"
+    ITERATION = "iteration"
+    LLM_CALL = "llm_call"
+    TOOL_EXECUTION = "tool_execution"
+    VERIFICATION = "verification"
+    FINISH = "finish"
+
+
+class LoopTransition(Enum):
+    STARTED = "started"
+    ITERATION_START = "iteration_start"
+    ITERATION_END = "iteration_end"
+    LLM_REQUEST = "llm_request"
+    LLM_RESPONSE = "llm_response"
+    TOOL_CALL = "tool_call"
+    TOOL_RESULT = "tool_result"
+    PASSED = "passed"
+    FAILED = "failed"
+    SUCCESS = "success"
+    ERROR = "error"
+    CANCELLED = "cancelled"
+    TIMEOUT = "timeout"
+
+
+@dataclass
+class RunTraceEvent:
+    phase: LoopPhase
+    transition: LoopTransition
+    iteration: int = 0
+    agent_name: str = ""
+    message: str = ""
+    metadata: dict[str, Any] = field(default_factory=dict)
+    at: str = ""
+
+    def __post_init__(self) -> None:
+        if not self.at:
+            self.at = datetime.now(timezone.utc).isoformat()
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "at": self.at,
+            "phase": self.phase.value,
+            "transition": self.transition.value,
+            "iteration": self.iteration,
+            "agent_name": self.agent_name,
+            "message": self.message,
+            "metadata": dict(self.metadata or {}),
+        }
+
+
+def run_trace_to_dicts(events: list[Any] | None) -> list[dict[str, Any]]:
+    result: list[dict[str, Any]] = []
+    for event in events or []:
+        if hasattr(event, "to_dict"):
+            result.append(event.to_dict())
+        elif isinstance(event, dict):
+            result.append(dict(event))
+    return result

package/runtime/orchestration/loop/tool_call_executor.py

@@ -0,0 +1,214 @@
+"""AgentLoop 状态机的工具调用执行适配器。"""
+
+from __future__ import annotations
+
+from runtime.core.llm.client import ToolCallRequest
+from runtime.orchestration.runtime.types import ToolResult as RuntimeToolResult
+from runtime.orchestration.loop.tool_execution_contract import (
+    build_execution_evidence,
+    build_policy_evidence,
+    build_error_evidence,
+    build_error_policy_evidence,
+)
+from tools.tool.schema import ToolCall, ToolContext
+
+
+class ToolCallExecutor:
+    """Execute model tool calls through an injected ToolRuntime and verify results."""
+
+    def __init__(self, tool_runtime, verifier, error_policy=None):
+        self.tool_runtime = tool_runtime
+        self.verifier = verifier
+        # ErrorPolicy 是可选的；如果注入则 tool 异常走它决策，否则直接 fail-fast
+        self.error_policy = error_policy
+
+    def execute(self, call: ToolCallRequest, *, agent_id: str, run_id: str):
+        from runtime.orchestration.loop.main_loop import ToolExec
+
+        if self.tool_runtime is None:
+            evidence: dict = {}
+            evidence["execution"] = build_execution_evidence(
+                call_id=call.id, tool_name=call.name, ok=False,
+                source="", provider_id="", safety="",
+            )
+            evidence["policy"] = build_policy_evidence(allowed=False, reason="tool_runtime 未配置")
+            evidence["error"] = build_error_evidence(type_="RuntimeError", message="tool_runtime 未配置")
+            evidence["error_policy"] = build_error_policy_evidence(action="fail", reason="no runtime")
+            return ToolExec(
+                name=call.name,
+                args=call.arguments,
+                result="ERROR: tool_runtime 未配置",
+                success=False,
+                evidence=evidence,
+            )
+
+        # 提取 approval 字段（如果 ToolCallRequest 携带）
+        approval_request_id = ""
+        approval_arguments: dict = {}
+        if isinstance(call, dict):
+            approval_request_id = call.get("approval_request_id", "") or ""
+            approval_arguments = call.get("approval_arguments", {}) or {}
+        else:
+            approval_request_id = getattr(call, "approval_request_id", "") or ""
+            approval_arguments = getattr(call, "approval_arguments", {}) or {}
+
+        try:
+            result = self.tool_runtime.invoke(
+                ToolCall(
+                    id=call.id,
+                    name=call.name,
+                    arguments=call.arguments or {},
+                    agent_id=agent_id,
+                    run_id=run_id,
+                ),
+                ToolContext(
+                    agent_id=agent_id,
+                    run_id=run_id,
+                    tool_name=call.name,
+                    approval_request_id=approval_request_id,
+                    approval_arguments=approval_arguments,
+                ),
+            )
+        except Exception as e:
+            # ErrorPolicy 路径：异常时评估动作
+            return self._handle_tool_exception(call, e)
+
+        # ── 统一构造 evidence ──
+        source = getattr(result.source, 'value', result.source) if hasattr(result, 'source') and result.source else ""
+        safety = getattr(result.safety, 'value', result.safety) if hasattr(result, 'safety') and result.safety else ""
+        audit = dict((result.evidence or {}).get("audit") or {})
+
+        evidence = {}
+        evidence["execution"] = build_execution_evidence(
+            call_id=call.id,
+            tool_name=call.name,
+            ok=bool(result.ok),
+            duration_ms=int(result.elapsed_ms or 0),
+            source=source,
+            provider_id=result.provider_id,
+            safety=safety,
+        )
+        # policy.allowed 反映策略是否放行，而非工具是否成功。
+        # 如果没有 audit 数据（工具未找到、短路返回），策略本身没拒绝。
+        has_audit = bool(audit)
+        policy_allowed = bool(audit.get("allowed", True)) if has_audit else True
+        evidence["policy"] = build_policy_evidence(
+            allowed=policy_allowed,
+            requires_confirmation=bool(audit.get("requires_confirmation", False)),
+            confirmed=bool(audit.get("confirmed", False)),
+            safety=safety or str(audit.get("safety", "")),
+            reason=str((result.evidence or {}).get("reason") or result.error or ""),
+        )
+        # 失败路径补 error
+        if not result.ok:
+            err_msg = result.error or result.to_display_content()
+            # 尝试从 error 文本中提取真实异常类型
+            err_type = "ToolError"
+            for known_type in ("RuntimeError", "ValueError", "TypeError", "KeyError",
+                               "FileNotFoundError", "PermissionError", "TimeoutError",
+                               "ConnectionError", "OSError"):
+                if known_type in err_msg:
+                    err_type = known_type
+                    break
+            evidence["error"] = build_error_evidence(type_=err_type, message=err_msg)
+
+        # 保留原始 evidence 中非冲突的 key (audit, reason, tool_name 等)
+        for k, v in (result.evidence or {}).items():
+            if k not in evidence:
+                evidence[k] = v
+
+        return ToolExec(
+            name=call.name,
+            args=call.arguments,
+            result=result.to_display_content(),
+            success=result.ok,
+            duration_ms=result.elapsed_ms,
+            source=source,
+            provider_id=result.provider_id,
+            safety=safety,
+            evidence=evidence,
+        )
+
+    def _handle_tool_exception(self, call, exc: Exception):
+        """异常路径：调 ErrorPolicy 决定下一步。
+
+        - 没有注入 policy → 直接 fail-fast（最安全）
+        - policy.action == FAIL → 中止
+        - policy.action == RETRY / CONTINUE / ESCALATE → 返回失败结果，由 AgentLoop 决定
+        """
+        from runtime.orchestration.loop.main_loop import ToolExec
+
+        # 统一 error evidence
+        error_ev = build_error_evidence(exc)
+
+        if self.error_policy is None:
+            evidence: dict = {}
+            evidence["execution"] = build_execution_evidence(
+                call_id=call.id, tool_name=call.name, ok=False,
+            )
+            evidence["policy"] = build_policy_evidence(allowed=True, reason="passed policy check; exception in tool")
+            evidence["error"] = error_ev
+            evidence["error_policy"] = build_error_policy_evidence(action="fail", reason="no error_policy injected")
+            return ToolExec(
+                name=call.name,
+                args=call.arguments,
+                result=f"ERROR (no policy): {exc}",
+                success=False,
+                evidence=evidence,
+            )
+        try:
+            from runtime.orchestration.runtime.error_policy import ErrorContext
+            ctx = ErrorContext(
+                error_class=type(exc).__name__,
+                error_message=str(exc),
+                consecutive_failures=1,
+                attempt=0,
+                max_attempts=int(getattr(self.error_policy, "max_retries", 2) or 2),
+            )
+            decision = self.error_policy.decide(ctx)
+        except Exception as e:
+            evidence = {}
+            evidence["execution"] = build_execution_evidence(call_id=call.id, tool_name=call.name, ok=False)
+            evidence["policy"] = build_policy_evidence(allowed=True, reason="passed policy check; exception in tool")
+            evidence["error"] = build_error_evidence(exc)
+            evidence["error_policy"] = build_error_policy_evidence(
+                action="fail", reason=f"error_policy.decide() raised: {e}",
+            )
+            return ToolExec(
+                name=call.name,
+                args=call.arguments,
+                result=f"ERROR (policy failed): {exc} | {e}",
+                success=False,
+                evidence=evidence,
+            )
+        from runtime.orchestration.runtime.error_policy import ErrorAction
+        action_str = decision.action.value if hasattr(decision.action, 'value') else str(decision.action)
+
+        evidence = {}
+        evidence["execution"] = build_execution_evidence(call_id=call.id, tool_name=call.name, ok=False)
+        evidence["policy"] = build_policy_evidence(allowed=True, reason="passed policy check; exception in tool")
+        evidence["error"] = error_ev
+        evidence["error_policy"] = build_error_policy_evidence(action=action_str, reason=decision.reason)
+
+        prefix = "ABORT" if decision.action == ErrorAction.FAIL else "ERROR"
+        return ToolExec(
+            name=call.name,
+            args=call.arguments,
+            result=f"{prefix} ({action_str}): {exc} | {decision.reason}",
+            success=False,
+            evidence=evidence,
+        )
+
+    def verify(self, call_id: str, record):
+        status = "success" if record.success else "error"
+        return self.verifier.verify(
+            RuntimeToolResult(
+                tool_name=record.name,
+                call_id=call_id,
+                status=status,
+                data=record.result if record.success else "",
+                error=record.result if not record.success else "",
+                evidence=[record.evidence] if record.evidence else [],
+                duration_ms=record.duration_ms,
+            )
+        )