Skip to content

armgit / avibe

Public Imported from GitHub
0

Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.

11.6 KB
Raw Blame
"""Backend liveness probe (B1) for the concise status bubble.

AgentService.backend_alive resolves the backend via the turn gate and delegates
to the per-backend probe; ClaudeAgent.backend_alive reads receiver_tasks.
Unknown states return None so the caller never false-alarms.
"""

from __future__ import annotations

import sys
import types
import unittest
from pathlib import Path
from unittest.mock import patch
from tests.codex_generation_support import init_generation_state, install_codex_transport

sys.path.insert(0, str(Path(__file__).resolve().parents[1]))

from modules.agents.base import AGENT_RUNTIME_TURN_KEY
from modules.agents.service import AgentService
from modules.agents.claude_agent import ClaudeAgent
from modules.agents.codex.agent import CodexAgent
from modules.agents.opencode.agent import OpenCodeAgent
from modules.agents.opencode.server import OpenCodeGeneration
from core.resource_governance import AgentResourceFailure
from modules.im import MessageContext


class _Task:
    def __init__(self, done: bool):
        self._done = done

    def done(self) -> bool:
        return self._done


def _ctx(runtime_key: str | None):
    ps = {AGENT_RUNTIME_TURN_KEY: runtime_key} if runtime_key is not None else {}
    return MessageContext(user_id="U1", channel_id="C1", platform="slack", platform_specific=ps)


class ClaudeBackendAliveTests(unittest.TestCase):
    def _agent(self, receiver_tasks):
        agent = ClaudeAgent.__new__(ClaudeAgent)  # bypass heavy __init__
        agent.receiver_tasks = receiver_tasks
        return agent

    def test_running_task_is_alive(self):
        agent = self._agent({"k1": _Task(done=False)})
        self.assertIs(agent.backend_alive(_ctx("k1")), True)

    def test_done_task_is_dead(self):
        agent = self._agent({"k1": _Task(done=True)})
        self.assertIs(agent.backend_alive(_ctx("k1")), False)

    def test_missing_key_is_unknown(self):
        agent = self._agent({"k1": _Task(done=False)})
        self.assertIsNone(agent.backend_alive(_ctx("other")))

    def test_no_runtime_key_is_unknown(self):
        agent = self._agent({"k1": _Task(done=False)})
        self.assertIsNone(agent.backend_alive(_ctx(None)))

    def test_captured_probe_stays_bound_to_receiver_generation(self):
        accepted = _Task(done=False)
        agent = self._agent({"k1": accepted})
        probe = agent.capture_backend_liveness(_ctx("k1"))

        accepted._done = True
        agent.receiver_tasks["k1"] = _Task(done=False)

        self.assertIs(agent.backend_alive(_ctx("k1")), True)
        self.assertIs(probe(), False)


class CodexBackendAliveTests(unittest.TestCase):
    def _agent(self, *, cwd_for_session, transports):
        agent = init_generation_state(object.__new__(CodexAgent))  # bypass heavy __init__
        agent._session_mgr = types.SimpleNamespace(get_cwd=lambda bid: cwd_for_session.get(bid))
        self.cwd_for_session = cwd_for_session
        for cwd, transport in transports.items():
            self._replace(agent, cwd, transport)
        return agent

    def _replace(self, agent, cwd, transport):
        """Start a new generation for ``cwd`` that its Sessions move to."""
        sessions = {base: "thread" for base, mapped in self.cwd_for_session.items() if mapped == cwd}
        install_codex_transport(
            agent, cwd, transport, sessions=sessions, digest=f"spec-{id(transport)}"
        )

    def _ctx_base(self, base_session_id):
        return MessageContext(
            user_id="U1", channel_id="C1", platform="slack",
            platform_specific={"turn_base_session_id": base_session_id} if base_session_id else {},
        )

    def test_alive_transport(self):
        agent = self._agent(
            cwd_for_session={"b1": "/repo"},
            transports={"/repo": types.SimpleNamespace(is_alive=True)},
        )
        self.assertIs(agent.backend_alive(self._ctx_base("b1")), True)

    def test_dead_transport(self):
        agent = self._agent(
            cwd_for_session={"b1": "/repo"},
            transports={"/repo": types.SimpleNamespace(is_alive=False)},
        )
        self.assertIs(agent.backend_alive(self._ctx_base("b1")), False)

    def test_no_transport_is_unknown(self):
        agent = self._agent(cwd_for_session={"b1": "/repo"}, transports={})
        self.assertIsNone(agent.backend_alive(self._ctx_base("b1")))

    def test_no_cwd_is_unknown(self):
        agent = self._agent(cwd_for_session={}, transports={})
        self.assertIsNone(agent.backend_alive(self._ctx_base("b1")))

    def test_no_base_session_is_unknown(self):
        agent = self._agent(cwd_for_session={"b1": "/repo"}, transports={})
        self.assertIsNone(agent.backend_alive(self._ctx_base(None)))

    def test_captured_probe_stays_bound_to_transport_generation(self):
        accepted = types.SimpleNamespace(
            is_alive=True,
            has_pending_notifications=False,
        )
        agent = self._agent(
            cwd_for_session={"b1": "/repo"},
            transports={"/repo": accepted},
        )
        context = self._ctx_base("b1")
        probe = agent.capture_backend_liveness(context)

        accepted.is_alive = False
        self._replace(agent, "/repo", types.SimpleNamespace(
            is_alive=True,
            has_pending_notifications=False,
        ))

        self.assertIs(agent.backend_alive(context), True)
        self.assertIs(probe(), False)

    def test_captured_exit_failure_uses_accepted_transport_after_replacement(self):
        process = types.SimpleNamespace(returncode=None)
        accepted = types.SimpleNamespace(is_alive=True, _process=process)
        agent = self._agent(
            cwd_for_session={"b1": "/repo"},
            transports={"/repo": accepted},
        )
        agent.controller = types.SimpleNamespace(
            config=types.SimpleNamespace(language="en")
        )
        diagnose = agent.capture_backend_exit_failure(self._ctx_base("b1"))
        self.assertIsNotNone(diagnose)
        process.returncode = 137
        self._replace(agent, "/repo", types.SimpleNamespace(
            is_alive=True,
            _process=types.SimpleNamespace(returncode=None),
        ))
        pressure = AgentResourceFailure(
            kind="pids",
            message="shared cgroup limit event",
            pids_current=0,
            pids_max=4096,
        )

        with patch(
            "modules.agents.codex.agent.observe_agent_resource_pressure",
            side_effect=[pressure, None],
        ) as observe:
            diagnostic, visible = diagnose()
            self.assertEqual(diagnose(), (diagnostic, visible))

        observe.assert_called_once_with(agent.controller)
        self.assertIn("Resource diagnosis: shared cgroup limit event", diagnostic)
        self.assertIn("(0/4096)", visible)

    def test_captured_exit_failure_caches_negative_pressure_check(self):
        process = types.SimpleNamespace(returncode=None)
        accepted = types.SimpleNamespace(is_alive=False, _process=process)
        agent = self._agent(
            cwd_for_session={"b1": "/repo"},
            transports={"/repo": accepted},
        )
        agent.controller = types.SimpleNamespace(
            config=types.SimpleNamespace(language="en")
        )
        diagnose = agent.capture_backend_exit_failure(self._ctx_base("b1"))
        self.assertIsNotNone(diagnose)
        later_pressure = AgentResourceFailure(
            kind="memory",
            message="pressure from a later process",
        )

        with patch(
            "modules.agents.codex.agent.observe_agent_resource_pressure",
            side_effect=[None, later_pressure],
        ) as observe:
            # The first liveness failure is not yet a confirmed process exit.
            self.assertIsNone(diagnose())
            observe.assert_not_called()
            process.returncode = 137
            self.assertIsNone(diagnose())
            self.assertIsNone(diagnose())

        observe.assert_called_once_with(agent.controller)


def _opencode_generation(generation_id: str, pid: int) -> OpenCodeGeneration:
    return OpenCodeGeneration(
        generation_id=generation_id,
        pid=pid,
        port=50000 + pid,
        spec_digest="spec",
        process_created_at=1000.0,
    )


def _opencode_agent() -> OpenCodeAgent:
    agent = OpenCodeAgent.__new__(OpenCodeAgent)
    agent.controller = types.SimpleNamespace()
    agent._resource_failures = {}
    return agent


class OpenCodeResourceExitTests(unittest.TestCase):
    def test_generation_exit_consumes_pressure_only_after_its_own_process_exits(self):
        agent = _opencode_agent()
        generation = _opencode_generation("ocg_a", 654)
        pressure = AgentResourceFailure(kind="pids", message="shared cgroup limit event")

        with patch(
            "modules.agents.opencode.server.runtime.pid_alive",
            return_value=True,
        ), patch(
            "modules.agents.opencode.server.runtime.process_create_time",
            # Alive, then the pid belongs to a later process.
            side_effect=[1000.0, 2000.0],
        ), patch(
            "modules.agents.opencode.agent.observe_agent_resource_pressure",
            return_value=pressure,
        ) as observe:
            self.assertIsNone(agent._resource_failure_for_server(generation))
            observe.assert_not_called()
            self.assertIs(agent._resource_failure_for_server(generation), pressure)
            observe.assert_called_once_with(agent.controller)

    def test_pressure_checks_are_cached_per_generation(self):
        agent = _opencode_agent()
        first = _opencode_generation("ocg_a", 654)
        second = _opencode_generation("ocg_b", 655)
        pressure = AgentResourceFailure(kind="pids", message="first exit")

        with patch(
            "modules.agents.opencode.server.runtime.process_create_time",
            return_value=None,
        ), patch(
            "modules.agents.opencode.server.runtime.pid_alive",
            return_value=False,
        ), patch(
            "modules.agents.opencode.agent.observe_agent_resource_pressure",
            side_effect=[pressure, None],
        ) as observe:
            self.assertIs(agent._resource_failure_for_server(first), pressure)
            self.assertIs(agent._resource_failure_for_server(first), pressure)
            self.assertIsNone(agent._resource_failure_for_server(second))
            self.assertIsNone(agent._resource_failure_for_server(second))

        self.assertEqual(observe.call_count, 2)


class AgentServiceBackendAliveTests(unittest.TestCase):
    def _service(self, *, backend_name, gate_backend, probe_return):
        svc = AgentService.__new__(AgentService)  # bypass __init__
        fake_agent = types.SimpleNamespace(backend_alive=lambda context: probe_return)
        svc.agents = {backend_name: fake_agent}
        svc._turn_gates = {"rk": types.SimpleNamespace(backend=gate_backend, token="t")}
        return svc

    def test_resolves_backend_via_gate_and_delegates(self):
        svc = self._service(backend_name="claude", gate_backend="claude", probe_return=True)
        self.assertIs(svc.backend_alive(_ctx("rk")), True)

    def test_dead_propagates(self):
        svc = self._service(backend_name="claude", gate_backend="claude", probe_return=False)
        self.assertIs(svc.backend_alive(_ctx("rk")), False)

    def test_unknown_backend_returns_none(self):
        svc = self._service(backend_name="claude", gate_backend="codex", probe_return=True)
        self.assertIsNone(svc.backend_alive(_ctx("rk")))

    def test_no_gate_returns_none(self):
        svc = self._service(backend_name="claude", gate_backend="claude", probe_return=True)
        self.assertIsNone(svc.backend_alive(_ctx("missing")))


if __name__ == "__main__":
    unittest.main()