Bello 0.6.0__py3-none-win_amd64.whl

bello-0.6.0.data/purelib/supervisor/__init__.py

@@ -0,0 +1,23 @@
+"""Supervisor Agent MVP package."""
+
+__all__ = ["__version__"]
+
+import importlib.metadata as _metadata
+import tomllib as _tomllib
+from pathlib import Path as _Path
+
+
+def _read_version() -> str:
+    try:
+        return _metadata.version("bello")
+    except _metadata.PackageNotFoundError:
+        pyproject = _Path(__file__).resolve().parents[1] / "pyproject.toml"
+        try:
+            data = _tomllib.loads(pyproject.read_text(encoding="utf-8"))
+        except OSError:
+            return "0+unknown"
+        version = data.get("project", {}).get("version")
+        return version if isinstance(version, str) else "0+unknown"
+
+
+__version__ = _read_version()

bello-0.6.0.data/purelib/supervisor/_build.py

@@ -0,0 +1,9 @@
+"""Build-time Bello source metadata fallback.
+
+Packagers may replace these constants during release builds. Runtime update
+checks prefer PEP 610 direct_url.json metadata when it is available.
+"""
+
+SOURCE_URL: str | None = None
+REQUESTED_REVISION: str | None = None
+COMMIT_SHA: str | None = None

bello-0.6.0.data/purelib/supervisor/adversary_agent.py

@@ -0,0 +1,388 @@
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Awaitable, Callable
+
+from supervisor.appserver import (
+    APP_SERVER_CLEANUP_RPC_TIMEOUT_SECONDS,
+    APP_SERVER_CONTROL_RPC_TIMEOUT_SECONDS,
+    AppServerClient,
+    AppServerError,
+    AppServerTimeoutError,
+    last_agent_message_text,
+    text_input,
+)
+from supervisor.coder import (
+    DEFAULT_INTELLIGENCE,
+    apply_intelligence,
+    apply_multi_agent_thread_start_params,
+)
+from supervisor.project_config import MultiAgentConfig
+from supervisor.prompts import build_adversary_prompt
+from supervisor.schemas import SupervisorWakePacket
+
+
+DEFAULT_ADVERSARY_TIMEOUT_SECONDS = 4000.0
+
+
+class AdversaryAgentError(RuntimeError):
+    pass
+
+
+class AdversaryAttemptError(AdversaryAgentError):
+    pass
+
+
+@dataclass(frozen=True)
+class AdversaryRunResult:
+    report_text: str
+    thread_id: str
+    turn_id: str
+    candidate_finding: bool
+
+
+def _denied_probes_retry_note(denied: list[str]) -> str:
+    lines = "\n".join(f"- {item}" for item in denied)
+    return (
+        "Retry note: your previous attempt ended without producing a report after command approval denials. "
+        "The following requests were denied:\n"
+        f"{lines}\n"
+        "Do not request these again and do not work around the denials; treat those areas as unreachable, "
+        "record them under not_reached, and complete the report using probes that run inside the snapshot sandbox."
+    )
+
+
+class AdversaryAgent:
+    def __init__(
+        self,
+        client: AppServerClient,
+        project_root: Path,
+        *,
+        model: str | None = None,
+        intelligence: str | None = DEFAULT_INTELLIGENCE,
+        timeout_seconds: float = DEFAULT_ADVERSARY_TIMEOUT_SECONDS,
+        on_thread_start: Callable[[str], None] | None = None,
+        on_thread_done: Callable[[str], None] | None = None,
+        denied_probes: Callable[[], list[str]] | None = None,
+        multi_agent: MultiAgentConfig | None = None,
+        before_thread_cleanup: Callable[[str, Path], Awaitable[None]] | None = None,
+    ):
+        self.client = client
+        self.project_root = project_root.resolve()
+        self.model = model
+        self.intelligence = intelligence
+        self.timeout_seconds = timeout_seconds
+        self.on_thread_start = on_thread_start
+        self.on_thread_done = on_thread_done
+        self.denied_probes = denied_probes
+        self.multi_agent = multi_agent or MultiAgentConfig()
+        self.before_thread_cleanup = before_thread_cleanup
+
+    async def run(
+        self,
+        packet: SupervisorWakePacket,
+        *,
+        previous_adversary_report: dict[str, Any] | None = None,
+    ) -> AdversaryRunResult:
+        prompt = build_adversary_prompt(
+            packet,
+            previous_adversary_report=previous_adversary_report,
+        )
+        last_error: str | None = None
+        for attempt in range(2):
+            attempt_prompt = prompt
+            if attempt:
+                # An approval denial can abort the whole turn before the agent gets a
+                # chance to record the area as not_reached, so a blind retry would just
+                # replay the same request and die the same way. Tell the fresh thread
+                # what was already refused so it routes around it and still reports.
+                denied = list(self.denied_probes()) if self.denied_probes else []
+                if denied:
+                    attempt_prompt = prompt + "\n\n" + _denied_probes_retry_note(denied)
+            try:
+                return await self._run_once(attempt_prompt)
+            except AdversaryAttemptError as exc:
+                last_error = str(exc)
+                if attempt == 1:
+                    raise
+        raise AdversaryAgentError(last_error or "adversary run failed")
+
+    async def _run_once(self, prompt: str) -> AdversaryRunResult:
+        thread_id: str | None = None
+        turn_id: str | None = None
+        try:
+            thread_response = await self._await_rpc(
+                "adversary thread/start response",
+                self.client.thread_start(self._thread_params(), timeout=APP_SERVER_CONTROL_RPC_TIMEOUT_SECONDS),
+                timeout=APP_SERVER_CONTROL_RPC_TIMEOUT_SECONDS,
+            )
+            thread = thread_response.get("thread", {})
+            thread_id = thread.get("id") if isinstance(thread, dict) else None
+            if not isinstance(thread_id, str):
+                raise AdversaryAgentError("adversary thread/start did not return thread id")
+            if self.on_thread_start:
+                self.on_thread_start(thread_id)
+
+            turn_response = await self._await_rpc(
+                "adversary turn/start response",
+                self.client.turn_start(
+                    self._turn_params(thread_id, prompt),
+                    timeout=self.timeout_seconds,
+                ),
+                timeout=self.timeout_seconds,
+            )
+            turn = turn_response.get("turn", {})
+            turn_id_value = turn.get("id") if isinstance(turn, dict) else None
+            if not isinstance(turn_id_value, str):
+                raise AdversaryAgentError("adversary turn/start did not return turn id")
+            turn_id = turn_id_value
+            status = turn.get("status")
+            if status in {"failed", "interrupted"}:
+                raise AdversaryAttemptError(_turn_failure_message(turn, thread_id=thread_id, turn_id=turn_id))
+            if status != "completed":
+                try:
+                    completed = await self.client.wait_for_notification(
+                        lambda message: _is_terminal_turn_notification(
+                            message,
+                            thread_id=thread_id,
+                            turn_id=turn_id,
+                        ),
+                        timeout=self.timeout_seconds,
+                    )
+                except (asyncio.TimeoutError, AppServerError) as exc:
+                    if isinstance(exc, (asyncio.TimeoutError, AppServerTimeoutError)):
+                        detail = f"timed out after {self.timeout_seconds:g}s"
+                    else:
+                        detail = f"failed with {exc.__class__.__name__}: {exc}"
+                    raise AdversaryAttemptError(
+                        f"adversary turn completion wait {detail} "
+                        f"thread_id={thread_id} turn_id={turn_id}"
+                    ) from exc
+                if completed.method == "error":
+                    raise AdversaryAttemptError(
+                        _turn_error_notification_message(
+                            completed.params,
+                            thread_id=thread_id,
+                            turn_id=turn_id,
+                        )
+                    )
+                turn = completed.params.get("turn", {})
+            if turn.get("status") != "completed":
+                raise AdversaryAttemptError(_turn_failure_message(turn, thread_id=thread_id, turn_id=turn_id))
+
+            text = last_agent_message_text(turn)
+            if text is None:
+                turns = await self._await_rpc(
+                    "adversary thread/turns/list response",
+                    self.client.thread_turns_list(
+                        thread_id,
+                        limit=5,
+                        items_view="full",
+                        timeout=APP_SERVER_CONTROL_RPC_TIMEOUT_SECONDS,
+                    ),
+                    timeout=APP_SERVER_CONTROL_RPC_TIMEOUT_SECONDS,
+                )
+                text = _agent_message_text_from_turns(turns.get("data", []), turn_id=turn_id)
+            if text is None or not text.strip():
+                raise AdversaryAttemptError("adversary did not produce an agent message")
+            report_text = text.strip()
+            return AdversaryRunResult(
+                report_text=report_text,
+                thread_id=thread_id,
+                turn_id=turn_id,
+                candidate_finding=_report_has_candidate_finding(report_text),
+            )
+        except AdversaryAgentError:
+            raise
+        except Exception as exc:
+            raise AdversaryAgentError(f"{exc.__class__.__name__}: {exc}") from exc
+        finally:
+            if thread_id is not None:
+                if self.before_thread_cleanup is not None:
+                    try:
+                        await self.before_thread_cleanup(thread_id, self.project_root)
+                    except Exception:
+                        pass
+                try:
+                    await self.client.thread_archive(thread_id, timeout=APP_SERVER_CLEANUP_RPC_TIMEOUT_SECONDS)
+                except Exception:
+                    try:
+                        await self.client.thread_unsubscribe(
+                            thread_id,
+                            timeout=APP_SERVER_CLEANUP_RPC_TIMEOUT_SECONDS,
+                        )
+                    except Exception:
+                        pass
+                if self.on_thread_done:
+                    self.on_thread_done(thread_id)
+
+    def _thread_params(self) -> dict[str, Any]:
+        params: dict[str, Any] = {
+            "cwd": str(self.project_root),
+            "runtimeWorkspaceRoots": [str(self.project_root)],
+            "approvalPolicy": "on-request",
+            "approvalsReviewer": "user",
+            "sandbox": "workspace-write",
+            "ephemeral": False,
+            "experimentalRawEvents": False,
+            "persistExtendedHistory": False,
+            "config": {},
+        }
+        apply_multi_agent_thread_start_params(
+            params,
+            self.multi_agent,
+            role="adversary",
+        )
+        if self.model:
+            params["model"] = self.model
+        return apply_intelligence(params, self.intelligence)
+
+    def _turn_params(self, thread_id: str, prompt: str) -> dict[str, Any]:
+        params: dict[str, Any] = {
+            "threadId": thread_id,
+            "input": [text_input(prompt)],
+            "cwd": str(self.project_root),
+            "runtimeWorkspaceRoots": [str(self.project_root)],
+            "approvalPolicy": "on-request",
+            "approvalsReviewer": "user",
+            "sandboxPolicy": {
+                "type": "workspaceWrite",
+                "writableRoots": [str(self.project_root)],
+                "networkAccess": False,
+            },
+        }
+        if self.model:
+            params["model"] = self.model
+        return apply_intelligence(params, self.intelligence)
+
+    async def _await_rpc(self, stage: str, awaitable: Any, *, timeout: float) -> Any:
+        try:
+            return await asyncio.wait_for(awaitable, timeout=timeout)
+        except asyncio.TimeoutError as exc:
+            raise AdversaryAgentError(f"{stage} timed out after {timeout:g}s") from exc
+        except AdversaryAgentError:
+            raise
+        except Exception as exc:
+            raise AdversaryAgentError(f"{stage} failed with {exc.__class__.__name__}: {exc}") from exc
+
+
+def _agent_message_text_from_turns(data: Any, *, turn_id: str | None) -> str | None:
+    if not isinstance(data, list):
+        return None
+    for turn in data:
+        if not isinstance(turn, dict):
+            continue
+        if turn_id is not None and turn.get("id") != turn_id:
+            continue
+        text = last_agent_message_text(turn)
+        if text:
+            return text
+    return None
+
+
+def _is_terminal_turn_notification(message: Any, *, thread_id: str, turn_id: str) -> bool:
+    params = message.params
+    if params.get("threadId") != thread_id:
+        return False
+    if message.method == "turn/completed":
+        turn = params.get("turn")
+        return isinstance(turn, dict) and turn.get("id") == turn_id
+    if message.method != "error" or params.get("turnId") != turn_id:
+        return False
+    # Codex can emit a transient error while it is already retrying the same turn.
+    # Let that built-in retry finish; only a terminal error should consume one of
+    # Bello's two fresh-thread adversary attempts.
+    return params.get("willRetry") is not True
+
+
+def _turn_error_notification_message(params: dict[str, Any], *, thread_id: str, turn_id: str) -> str:
+    error = params.get("error")
+    details: list[str] = []
+    if isinstance(error, dict):
+        message = error.get("message")
+        if isinstance(message, str) and message.strip():
+            details.append(message.strip())
+        codex_error_info = error.get("codexErrorInfo")
+        if codex_error_info is not None:
+            details.append(f"codexErrorInfo={codex_error_info!r}")
+        additional = error.get("additionalDetails")
+        if isinstance(additional, str) and additional.strip():
+            details.append(additional.strip())
+    elif isinstance(error, str) and error.strip():
+        details.append(error.strip())
+    message = params.get("message")
+    if not details and isinstance(message, str) and message.strip():
+        details.append(message.strip())
+    detail_text = f": {'; '.join(details)}" if details else ""
+    return (
+        "adversary turn received terminal app-server error "
+        f"thread_id={thread_id} turn_id={turn_id}{detail_text}"
+    )
+
+
+def _turn_failure_message(turn: Any, *, thread_id: str, turn_id: str) -> str:
+    status = turn.get("status") if isinstance(turn, dict) else None
+    error = turn.get("error") if isinstance(turn, dict) else None
+    details: list[str] = []
+    if isinstance(error, dict):
+        message = error.get("message")
+        if isinstance(message, str) and message.strip():
+            details.append(message.strip())
+        codex_error_info = error.get("codexErrorInfo")
+        if codex_error_info is not None:
+            details.append(f"codexErrorInfo={codex_error_info!r}")
+        additional = error.get("additionalDetails")
+        if isinstance(additional, str) and additional.strip():
+            details.append(additional.strip())
+    detail_text = f": {'; '.join(details)}" if details else ""
+    return (
+        f"adversary turn ended with status={status!r} "
+        f"thread_id={thread_id} turn_id={turn_id}{detail_text}"
+    )
+
+
+def _report_has_candidate_finding(report_text: str) -> bool:
+    """Extract informational metadata; every nonempty report goes to the report controller."""
+    lowered_lines = [line.strip().lower() for line in report_text.splitlines() if line.strip()]
+    for index, line in enumerate(lowered_lines):
+        if line.startswith("candidate_finding:"):
+            value = line.split(":", 1)[1].strip()
+            if value in {"false", "no", "none", "0"}:
+                return False
+            if value in {"true", "yes", "1"}:
+                return True
+        if line.startswith("findings:"):
+            value = line.split(":", 1)[1].strip()
+            if value:
+                return value not in {"none", "no", "no findings", "nothing", "n/a", "not found"}
+            for following in lowered_lines[index + 1 :]:
+                if _looks_like_report_section(following):
+                    return False
+                normalized = following.lstrip("-*0123456789. )").strip()
+                if not normalized or normalized in {"none", "no", "no findings", "nothing", "n/a", "not found"}:
+                    continue
+                return True
+            return False
+    return True
+
+
+def _looks_like_report_section(line: str) -> bool:
+    prefixes = (
+        "attacked:",
+        "previous_findings_checked:",
+        "previous findings checked:",
+        "findings:",
+        "observations:",
+        "held:",
+        "not_reached:",
+        "not reached:",
+        "overall:",
+        "candidate_finding:",
+        "candidate finding:",
+    )
+    normalized = line.lstrip("-* \t")
+    if any(normalized.startswith(prefix) for prefix in prefixes):
+        return True
+    return False