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.

17.3 KB
Raw Blame
from __future__ import annotations

import unittest
from types import SimpleNamespace
from unittest.mock import ANY, AsyncMock, call

from core.backend_failure import emit_backend_failure, terminal_backend_failure_output
from core.delivery_evidence import DeliveryEvidence
from core.message_output import MessageOutput
from modules.agents.base import AgentRequest
from modules.im import MessageContext


def _request() -> AgentRequest:
    context = MessageContext(
        user_id="U1",
        channel_id="C1",
        platform="avibe",
        platform_specific={"turn_token": "turn-1"},
    )
    return AgentRequest(
        context=context,
        message="work",
        user_message="work",
        working_path="/tmp/work",
        base_session_id="session-1",
        composite_session_id="session-1:/tmp/work",
        session_key="avibe::project::p1",
    )


class BackendFailureTests(unittest.IsolatedAsyncioTestCase):
    async def test_terminal_contract_never_downgrades_existing_delivery_evidence(
        self,
    ) -> None:
        request = _request()
        output = MessageOutput(
            completes_turn=True,
            completes_run=True,
            metadata={
                "turn_failure_notification": {
                    "failure_id": "turn:turn-1",
                    "ack_evidence": "receipt",
                    "delivered": True,
                    "fallback_run_id": "run-owner",
                }
            },
        )

        merged = terminal_backend_failure_output(
            request.context,
            request=request,
            output=output,
            delivery=DeliveryEvidence(),
        )

        self.assertEqual(
            merged.metadata["turn_failure_notification"],
            {
                "failure_id": "turn:turn-1",
                "ack_evidence": "receipt",
                "delivered": True,
                "fallback_run_id": "run-owner",
            },
        )

    async def test_turn_without_current_runs_preserves_primary_delivery_for_late_runs(
        self,
    ) -> None:
        request = _request()
        emissions = []

        async def emit(context, message_type, text, **kwargs):
            emissions.append((message_type, text, kwargs))
            evidence = kwargs.get("delivery")
            if message_type == "notify" and evidence is not None:
                evidence.persisted_row = {"id": "msg-primary"}
                return "msg-primary"
            return None

        controller = SimpleNamespace(
            agent_auth_service=SimpleNamespace(),
            emit_agent_message=emit,
        )

        await emit_backend_failure(
            controller,
            request.context,
            "codex",
            "provider unavailable",
            request=request,
        )

        terminal_output = emissions[1][2]["output"]
        self.assertEqual(
            terminal_output.metadata["turn_failure_notification"],
            {
                "failure_id": "turn-1",
                "ack_evidence": "receipt",
                "delivered": True,
            },
        )

    async def test_harness_turn_notifies_live_and_carries_delivery_evidence_to_settlement(
        self,
    ) -> None:
        request = _request()
        request.context.platform_specific.update(
            {
                "task_execution_id": "run-watch-1",
                "task_trigger_kind": "watch",
            }
        )
        emissions = []

        async def emit(context, message_type, text, **kwargs):
            emissions.append((message_type, text, kwargs))
            evidence = kwargs.get("delivery")
            if message_type == "notify" and evidence is not None:
                evidence.delivered_id = "msg-1"
                evidence.persisted_row = {"id": "msg-1"}
                evidence.send_returned = True
                return "msg-1"
            return None

        auth = AsyncMock(return_value=False)
        controller = SimpleNamespace(
            agent_auth_service=SimpleNamespace(maybe_emit_auth_recovery_message=auth),
            emit_agent_message=emit,
        )

        handled_auth = await emit_backend_failure(
            controller,
            request.context,
            "codex",
            "provider unavailable",
            request=request,
        )

        self.assertFalse(handled_auth)
        auth.assert_not_awaited()
        self.assertEqual([message_type for message_type, _text, _kwargs in emissions], ["notify", "result"])
        notify_output = emissions[0][2]["output"]
        self.assertEqual(notify_output.idempotency_key, "backend-failure:turn:turn-1")
        terminal_output = emissions[1][2]["output"]
        self.assertEqual(
            terminal_output.metadata["turn_failure_notification"],
            {
                "failure_id": "turn:turn-1",
                "ack_evidence": "receipt",
                "delivered": True,
            },
        )

    async def test_run_attached_to_an_existing_turn_keeps_harness_failure_ownership(
        self,
    ) -> None:
        request = _request()
        request.context.platform_specific["accepted_agent_run_ids"] = [
            "run-attached-1"
        ]
        emissions = []

        async def emit(context, message_type, text, **kwargs):
            emissions.append((message_type, kwargs))
            evidence = kwargs.get("delivery")
            if message_type == "notify" and evidence is not None:
                evidence.persisted_row = {"id": "msg-attached"}
                return "msg-attached"
            return None

        auth = AsyncMock(return_value=False)
        controller = SimpleNamespace(
            agent_auth_service=SimpleNamespace(maybe_emit_auth_recovery_message=auth),
            emit_agent_message=emit,
        )

        await emit_backend_failure(
            controller,
            request.context,
            "codex",
            "stream disconnected",
            request=request,
        )

        auth.assert_not_awaited()
        self.assertEqual([message_type for message_type, _kwargs in emissions], ["notify", "result"])
        self.assertEqual(
            emissions[1][1]["output"].metadata["turn_failure_notification"],
            {
                "failure_id": "turn:turn-1",
                "ack_evidence": "receipt",
                "delivered": True,
            },
        )

    async def test_suppressed_harness_notification_does_not_ack_local_message_id(
        self,
    ) -> None:
        request = _request()
        request.context.platform = "slack"
        request.context.platform_specific.update(
            {
                "task_execution_id": "run-background-1",
                "task_trigger_kind": "watch",
                "suppress_delivery": True,
            }
        )
        emissions = []

        async def emit(_context, message_type, _text, **kwargs):
            emissions.append((message_type, kwargs))
            if message_type == "notify":
                return "suppressed:run-background-1"
            return None

        controller = SimpleNamespace(
            agent_auth_service=SimpleNamespace(
                maybe_emit_auth_recovery_message=AsyncMock(return_value=False)
            ),
            emit_agent_message=emit,
        )

        await emit_backend_failure(
            controller,
            request.context,
            "codex",
            "stream disconnected",
            request=request,
        )

        terminal_output = emissions[1][1]["output"]
        self.assertEqual(
            terminal_output.metadata["turn_failure_notification"],
            {
                "failure_id": "turn:turn-1",
                "ack_evidence": None,
                "delivered": False,
            },
        )

    async def test_hfr_454_delivery_only_ack_uses_the_routed_target_platform(
        self,
    ) -> None:
        """HFR-454: Transport-only ids are evidence according to where the notify was sent."""

        for source, target, expected in (
            ("avibe", "slack", True),
            ("slack", "avibe", False),
        ):
            with self.subTest(source=source, target=target):
                request = _request()
                request.context.platform = source
                request.context.platform_specific.update(
                    {
                        "task_execution_id": f"run-{source}-to-{target}",
                        "delivery_override": {
                            "platform": target,
                            "channel_id": f"channel-{target}",
                        },
                    }
                )
                emissions = []

                async def emit(_context, message_type, _text, **kwargs):
                    emissions.append((message_type, kwargs))
                    evidence = kwargs.get("delivery")
                    if message_type == "notify" and evidence is not None:
                        evidence.delivered_id = f"native-{target}-id"
                        evidence.send_returned = True
                    return None

                controller = SimpleNamespace(
                    agent_auth_service=SimpleNamespace(
                        maybe_emit_auth_recovery_message=AsyncMock(return_value=False)
                    ),
                    emit_agent_message=emit,
                )

                await emit_backend_failure(
                    controller,
                    request.context,
                    "codex",
                    "stream disconnected",
                    request=request,
                )

                notification = emissions[1][1]["output"].metadata[
                    "turn_failure_notification"
                ]
                self.assertEqual(notification["ack_evidence"], "delivery_only")
                self.assertIs(notification["delivered"], expected)

    async def test_delivery_only_ack_fails_closed_without_target_platform(
        self,
    ) -> None:
        request = _request()
        request.context.platform = None
        emissions = []

        async def emit(_context, message_type, _text, **kwargs):
            emissions.append((message_type, kwargs))
            evidence = kwargs.get("delivery")
            if message_type == "notify" and evidence is not None:
                evidence.delivered_id = "synthetic-id"
                evidence.send_returned = True
            return None

        controller = SimpleNamespace(
            agent_auth_service=SimpleNamespace(
                maybe_emit_auth_recovery_message=AsyncMock(return_value=False)
            ),
            emit_agent_message=emit,
        )

        await emit_backend_failure(
            controller,
            request.context,
            "codex",
            "stream disconnected",
            request=request,
        )

        notification = emissions[1][1]["output"].metadata[
            "turn_failure_notification"
        ]
        self.assertEqual(notification["ack_evidence"], "delivery_only")
        self.assertFalse(notification["delivered"])

    async def test_auth_recovery_owns_the_only_terminal_settlement(self) -> None:
        request = _request()
        controller = SimpleNamespace(
            agent_auth_service=SimpleNamespace(
                maybe_emit_auth_recovery_message=AsyncMock(return_value=True)
            ),
            emit_agent_message=AsyncMock(),
        )

        handled_auth = await emit_backend_failure(
            controller,
            request.context,
            "claude",
            "401 Unauthorized",
            request=request,
        )

        self.assertTrue(handled_auth)
        controller.emit_agent_message.assert_not_awaited()

    async def test_settles_lifecycle_when_auth_recovery_delivery_raises(self) -> None:
        request = _request()
        controller = SimpleNamespace(
            agent_auth_service=SimpleNamespace(
                maybe_emit_auth_recovery_message=AsyncMock(
                    side_effect=RuntimeError("button delivery unavailable")
                )
            ),
            emit_agent_message=AsyncMock(),
        )

        with self.assertRaisesRegex(RuntimeError, "button delivery unavailable"):
            await emit_backend_failure(
                controller,
                request.context,
                "codex",
                "401 Unauthorized",
                request=request,
            )

        terminal_call = controller.emit_agent_message.await_args
        self.assertEqual(terminal_call.args, (request.context, "result", ""))
        self.assertTrue(terminal_call.kwargs["is_error"])
        self.assertEqual(terminal_call.kwargs["level"], "silent")
        self.assertEqual(terminal_call.kwargs["terminal_error"], "401 Unauthorized")
        self.assertEqual(
            terminal_call.kwargs["output"].metadata["turn_failure_notification"],
            {
                "failure_id": "turn-1",
                "ack_evidence": None,
                "delivered": False,
            },
        )

    async def test_separates_notify_from_terminal_settlement(self) -> None:
        request = _request()
        controller = SimpleNamespace(
            agent_auth_service=SimpleNamespace(
                maybe_emit_auth_recovery_message=AsyncMock(return_value=False)
            ),
            emit_agent_message=AsyncMock(),
        )

        handled_auth = await emit_backend_failure(
            controller,
            request.context,
            "codex",
            "provider unavailable",
            display_text="Codex failed: provider unavailable",
            request=request,
        )

        self.assertFalse(handled_auth)
        auth_call = controller.agent_auth_service.maybe_emit_auth_recovery_message.await_args
        self.assertEqual(
            auth_call.args,
            (request.context, "codex", "Codex failed: provider unavailable"),
        )
        self.assertEqual(auth_call.kwargs["terminal_error"], "provider unavailable")
        notify_call, terminal_call = controller.emit_agent_message.await_args_list
        self.assertEqual(
            notify_call,
            call(
                request.context,
                "notify",
                "Codex failed: provider unavailable",
                parse_mode="markdown",
                output=ANY,
                delivery=ANY,
            ),
        )
        self.assertFalse(notify_call.kwargs["output"].settles_run)
        self.assertEqual(
            notify_call.kwargs["output"].idempotency_key,
            "backend-failure:turn-1",
        )
        self.assertEqual(
            notify_call.kwargs["output"].metadata,
            {
                "backend": "codex",
                "event": "backend_failure",
                "failure_id": "turn-1",
            },
        )
        self.assertEqual(
            terminal_call,
            call(
                request.context,
                "result",
                "",
                parse_mode="markdown",
                is_error=True,
                level="silent",
                output=ANY,
                terminal_error="provider unavailable",
            ),
        )
        self.assertEqual(
            terminal_call.kwargs["output"].metadata["turn_failure_notification"],
            {
                "failure_id": "turn-1",
                "ack_evidence": "delivery_only",
                "delivered": False,
            },
        )

    async def test_identity_is_stable_for_duplicate_terminal_events(self) -> None:
        request = _request()
        controller = SimpleNamespace(
            agent_auth_service=SimpleNamespace(
                maybe_emit_auth_recovery_message=AsyncMock(return_value=False)
            ),
            emit_agent_message=AsyncMock(),
        )

        await emit_backend_failure(controller, request.context, "claude", "server error", request=request)
        await emit_backend_failure(controller, request.context, "claude", "server error", request=request)

        notify_outputs = [
            item.kwargs["output"]
            for item in controller.emit_agent_message.await_args_list
            if item.args[1] == "notify"
        ]
        self.assertEqual(
            [output.idempotency_key for output in notify_outputs],
            ["backend-failure:turn-1", "backend-failure:turn-1"],
        )

    async def test_settles_lifecycle_when_notify_raises(self) -> None:
        request = _request()
        terminal_calls = []

        async def emit(_context, message_type, _text, **kwargs):
            if message_type == "notify":
                raise RuntimeError("delivery unavailable")
            terminal_calls.append(kwargs)

        controller = SimpleNamespace(
            agent_auth_service=SimpleNamespace(
                maybe_emit_auth_recovery_message=AsyncMock(return_value=False)
            ),
            emit_agent_message=emit,
        )

        with self.assertRaisesRegex(RuntimeError, "delivery unavailable"):
            await emit_backend_failure(
                controller,
                request.context,
                "opencode",
                "transport failed",
                request=request,
            )

        self.assertEqual(len(terminal_calls), 1)
        self.assertTrue(terminal_calls[0]["is_error"])
        self.assertEqual(terminal_calls[0]["level"], "silent")
        self.assertEqual(terminal_calls[0]["terminal_error"], "transport failed")
        self.assertEqual(
            terminal_calls[0]["output"].metadata["turn_failure_notification"],
            {
                "failure_id": "turn-1",
                "ack_evidence": None,
                "delivered": False,
            },
        )