Skip to content

Dodaios is an open-source agent OS for your desktop: it runs your coding agents, browser and apps by voice or chat, on your own machine. Formerly Personal Jarvis.

17.0 KB
Raw Blame
"""Chat controls preserve history, serialize goals and never infer commands from text."""

from __future__ import annotations

import asyncio
from pathlib import Path
from typing import Any

import pytest

from dodaios.agent_chat.control import ChatControls
from dodaios.agent_chat.control_store import ControlStore
from dodaios.agent_chat.control_types import COMMANDS, CommandRequest, GoalVerdict
from dodaios.agent_chat.events import make_event
from dodaios.agent_chat.store import AgentChatStore


class FakeService:
    def __init__(self, store: Any = None) -> None:
        self.store = store or AgentChatStore()
        self.sent: list[tuple[str, dict]] = []
        self.notices: list[dict] = []
        self.running: dict[str, asyncio.Task] = {}
        self.gate: asyncio.Event | None = None
        self.cancelled = 0

    async def post_notice(self, sid: str, data: dict) -> None:
        self.notices.append(data)
        self.store.append_event(sid, make_event("notice", data))

    async def _emit(self, sid: str, event: dict) -> None:
        self.store.append_event(sid, event)

    def is_running(self, sid: str) -> bool:
        return sid in self.running

    async def bind_society_session(self, sid: str):
        # This unit fake has no roster; return its current stored seat.
        return self.store.get_session(sid)

    async def send(self, sid: str, text: str, **kwargs: Any) -> str:
        assert sid not in self.running
        self.sent.append((text, kwargs))
        tid = str(len(self.sent))

        async def work() -> None:
            try:
                if self.gate:
                    await self.gate.wait()
                await self._emit(
                    sid,
                    make_event("assistant_text", {"turn_id": tid, "text": "Actual work product"}),
                )
                await self._emit(
                    sid, make_event("turn_finished", {"turn_id": tid, "status": "done"})
                )
            finally:
                self.running.pop(sid, None)

        self.running[sid] = asyncio.create_task(work())
        return tid

    async def wait_turn(self, sid: str) -> None:
        task = self.running.get(sid)
        if task:
            await asyncio.shield(task)

    async def cancel(self, sid: str) -> bool:
        task = self.running.get(sid)
        if task:
            self.cancelled += 1
            task.cancel()
            await asyncio.gather(task, return_exceptions=True)
        return task is not None


def seat(service: FakeService, name: str = "society:test") -> str:
    service.store.create_session(
        session_id=name,
        provider="openai",
        model="test",
        effort="low",
        cwd=".",
        surface="society",
        permission_mode="ask",
    )
    return name


def request(command: str, arguments: str = "", rid: str = "r1") -> CommandRequest:
    return CommandRequest(command=command, arguments=arguments, request_id=rid)


async def test_rejected_message_cannot_replace_a_newer_control_status() -> None:
    svc = FakeService()
    sid = seat(svc)
    controls = ChatControls(svc, adapters=[])
    first_revision = await controls.user_message(sid, "Same text")
    second_revision = await controls.user_message(sid, "Same text")
    assert first_revision is not None and second_revision is not None
    assert second_revision > first_revision

    await controls.message_rejected(sid, "Same text", first_revision)
    state = controls.state(sid)
    assert state.last_status == "running"
    assert state.revision == second_revision

    await controls.message_rejected(sid, "Same text", second_revision)
    assert controls.state(sid).last_status == "failed"


async def test_continue_preserves_a_rate_limited_question_and_its_approval_mode():
    svc = FakeService()
    sid = seat(svc)
    question = "Was ist deine Aufgabe"
    svc.store.append_event(sid, make_event("user_message", {"text": question}))
    svc.store.append_event(
        sid,
        make_event(
            "turn_finished",
            {
                "turn_id": "limited",
                "status": "error",
                "error": "HTTP 429; use /continue later",
            },
        ),
    )
    controls = ChatControls(svc, adapters=[])
    result = await controls.execute(sid, request("continue"))
    assert result.status == "started"
    await svc.wait_turn(sid)
    assert question in svc.sent[-1][0]
    assert svc.store.list_events(sid)[0]["payload"]["text"] == question
    session = svc.store.get_session(sid)
    assert session.permission_mode == "ask" and session.provider == "openai"


async def test_continue_names_why_a_delegated_failure_cannot_be_resumed():
    svc = FakeService()
    sid = seat(svc)
    # A teammate's message: delivered without a user_message, then rate limited.
    svc.store.append_event(sid, make_event("turn_started", {"turn_id": "incoming"}))
    svc.store.append_event(
        sid,
        make_event("turn_finished", {"turn_id": "incoming", "status": "error", "error": "429"}),
    )
    controls = ChatControls(svc, adapters=[])
    result = await controls.execute(sid, request("continue"))
    assert result.status == "failed"
    assert "not from you" in result.error
    assert svc.sent == []


async def test_continue_without_any_failure_says_there_is_nothing_to_continue():
    svc = FakeService()
    sid = seat(svc)
    controls = ChatControls(svc, adapters=[])
    result = await controls.execute(sid, request("continue"))
    assert result.status == "failed"
    assert result.error == "There is no interrupted task to continue"


def test_plan_build_and_review_preserve_original_permissions_and_history() -> None:
    async def scenario() -> None:
        svc = FakeService()
        sid = seat(svc)
        controls = ChatControls(svc, adapters=[])
        svc.store.append_event(sid, make_event("user_message", {"text": "Original context"}))
        result = await controls.execute(sid, request("plan", "Investigate first"))
        assert result.status == "started"
        await svc.wait_turn(sid)
        await controls.turn_completed(sid, "1", "Investigate first", True, False)
        assert controls.state(sid).plan == "Actual work product"
        assert controls.state(sid).previous_permission == "ask"
        assert svc.store.permission_override(sid) == "plan"
        result = await controls.execute(sid, request("message", "@Friend Hello", "r2"))
        assert result.status == "failed" and "Plan mode" in result.error
        await controls.execute(sid, request("build", rid="r3"))
        await svc.wait_turn(sid)
        assert svc.store.get_session(sid).permission_mode == "ask"
        assert svc.store.permission_override(sid) == "ask"
        await controls.execute(sid, request("review", rid="r4"))
        await svc.wait_turn(sid)
        assert svc.sent[-1][1]["read_only"] is True
        assert svc.store.get_session(sid).permission_mode == "ask"
        assert svc.store.list_events(sid)[0]["payload"]["text"] == "Original context"

    asyncio.run(scenario())


def test_receipts_deduplicate_start_and_reject_request_id_reuse() -> None:
    async def scenario() -> None:
        svc = FakeService()
        sid = seat(svc)
        controls = ChatControls(svc, adapters=[])
        first = await controls.execute(sid, request("recap"))
        second = await controls.execute(sid, request("recap"))
        assert first == second
        assert len(svc.sent) == 1
        with pytest.raises(ValueError, match="another command"):
            await controls.execute(sid, request("review"))
        await svc.wait_turn(sid)

    asyncio.run(scenario())


def test_goal_rechecks_results_and_stops_after_three_stalled_steps() -> None:
    async def verdict(*_: Any) -> GoalVerdict:
        return GoalVerdict(
            status="continue", reason="Missing the requested artifact", progress=False
        )

    async def scenario() -> None:
        svc = FakeService()
        sid = seat(svc)
        controls = ChatControls(svc, evaluator=verdict, adapters=[])
        await controls.execute(sid, request("goal", "Produce an artifact"))
        await controls.jobs[sid]
        goal = controls.state(sid).goal
        assert goal.status == "blocked"
        assert goal.steps == goal.stalled_steps == 3
        assert len(svc.sent) == 3
        assert all(not flags["direct_user"] for _, flags in svc.sent)

    asyncio.run(scenario())


def test_goal_completion_requires_evidence_and_stop_cannot_be_undone_by_late_verdict() -> None:
    async def scenario() -> None:
        svc = FakeService()
        sid = seat(svc)
        checking = asyncio.Event()
        release = asyncio.Event()

        async def verdict(*_: Any) -> GoalVerdict:
            checking.set()
            await release.wait()
            return GoalVerdict(status="complete", reason="Verified", evidence=["1"], progress=True)

        controls = ChatControls(svc, evaluator=verdict, adapters=[])
        await controls.execute(sid, request("goal", "Write the artifact"))
        await checking.wait()
        await controls.execute(sid, request("stop", rid="stop"))
        release.set()
        await asyncio.sleep(0)
        assert controls.state(sid).goal.status == "paused"
        assert sid not in controls.jobs
        await controls.execute(sid, request("continue", rid="resume"))
        await controls.jobs[sid]
        assert controls.state(sid).goal.status == "complete"

    asyncio.run(scenario())


def test_stop_interrupts_work_and_preserves_goal_for_resume() -> None:
    async def scenario() -> None:
        svc = FakeService()
        sid = seat(svc)
        svc.gate = asyncio.Event()
        controls = ChatControls(svc, adapters=[])
        await controls.execute(sid, request("goal", "Work"))
        await asyncio.sleep(0)
        await asyncio.sleep(0)
        await controls.execute(sid, request("stop", rid="stop"))
        assert svc.cancelled == 1
        assert controls.state(sid).goal.objective == "Work"
        assert controls.state(sid).goal.status == "paused"
        assert not svc.is_running(sid)

    asyncio.run(scenario())


def test_persisted_goals_are_paused_after_restart(tmp_path: Path) -> None:
    async def scenario() -> None:
        path = tmp_path / "chat.db"
        svc = FakeService(AgentChatStore(path))
        sid = seat(svc)
        svc.gate = asyncio.Event()
        controls = ChatControls(svc, adapters=[])
        await controls.execute(sid, request("goal", "Keep the goal"))
        # Simulate recovery from a process that persisted active state and then died.
        restored = ControlStore(AgentChatStore(path))
        assert restored.get(sid).goal.status == "paused"
        assert restored.get(sid).goal.objective == "Keep the goal"
        await controls.close()

    asyncio.run(scenario())


def test_find_is_scoped_and_does_not_execute_old_commands() -> None:
    async def scenario() -> None:
        svc = FakeService()
        sid, other = seat(svc), seat(svc, "society:other")
        svc.store.append_event(sid, make_event("user_message", {"text": "/goal confidential"}))
        svc.store.append_event(
            other, make_event("user_message", {"text": "confidential in other chat"})
        )
        controls = ChatControls(svc, adapters=[])
        result = await controls.execute(sid, request("find", "confidential"))
        assert len(result.data["hits"]) == 1
        assert result.data["hits"][0]["session_id"] == sid
        assert not svc.sent and controls.state(sid).goal is None
        assert len(COMMANDS) == 16

    asyncio.run(scenario())


def test_build_never_elevates_an_initial_read_only_seat() -> None:
    async def scenario() -> None:
        svc = FakeService()
        sid = seat(svc)
        svc.store.update_session(sid, permission_mode="plan")
        controls = ChatControls(svc, adapters=[])
        result = await controls.execute(sid, request("build"))
        assert result.status == "failed"
        assert svc.store.get_session(sid).permission_mode == "plan"
        assert not svc.sent

    asyncio.run(scenario())


def test_goal_attachments_are_saved_and_read_before_work_starts() -> None:
    async def verify(*_: Any) -> GoalVerdict:
        return GoalVerdict(
            status="complete", reason="The result is present", evidence=["1"], progress=True
        )

    async def scenario() -> None:
        svc = FakeService()
        sid = seat(svc)
        controls = ChatControls(svc, adapters=[], evaluator=verify)
        files = [
            {
                "name": "brief.txt",
                "reference": "brief.txt",
                "kind": "text",
                "detail": "Source material",
                "described_by": "extraction",
                "note": "",
            }
        ]
        await controls.execute(
            sid,
            CommandRequest(
                command="goal", arguments="Use the brief", attachments=files, request_id="files"
            ),
        )
        assert controls.store.inputs(sid) == files
        await controls.jobs[sid]
        assert svc.sent[0][1]["attachments"] == files
        assert svc.sent[0][1]["read_only"] is True
        assert controls.store.inputs(sid) == []
        assert controls.state(sid).goal.status == "complete"

    asyncio.run(scenario())


@pytest.mark.parametrize("environment", ["local", "sandbox"])
def test_message_uses_executor_exact_text_sender_and_idempotency(
    monkeypatch: Any, environment: str,
) -> None:
    from types import SimpleNamespace

    from dodaios.agent_chat.service import AgentChatService
    from dodaios.core.bus import EventBus
    from dodaios.core.config import SafetyConfig
    from dodaios.core.protocols import ToolResult
    from dodaios.safety.approval import ApprovalWorkflow
    from dodaios.safety.risk_tier import RiskTierEvaluator
    from dodaios.safety.tool_executor import ToolExecutor

    calls = []

    class MessageTool:
        name = "society_message_agent"
        risk_tier = "safe"
        is_action_tool = True
        schema = {}

        def __init__(self, runtime: Any, agent_id: str) -> None:
            self.agent_id = agent_id

        async def execute(self, args: dict, ctx: Any) -> ToolResult:
            calls.append((self.agent_id, args, ctx))
            return ToolResult(
                True, {"status": "queued", "target": args["target"], "text": args["text"]}
            )

    async def scenario() -> None:
        bus = EventBus()
        executor = ToolExecutor(bus, RiskTierEvaluator(SafetyConfig()), ApprovalWorkflow(bus))
        monkeypatch.setattr(
            "dodaios.agent_chat.runner_brain.brain_manager",
            lambda: SimpleNamespace(_tool_executor=executor),
        )

        async def completed(*_: Any) -> None:
            return None

        async def live_agent(_agent_id: str) -> Any:
            return SimpleNamespace(execution_environment=environment)

        runtime = SimpleNamespace(
            roster=SimpleNamespace(get=live_agent),
            conversations=SimpleNamespace(checkpoint=lambda _: (0, "")),
            turn_completed=completed,
            browser=SimpleNamespace(live=SimpleNamespace(sessions={})),
        )
        from dodaios.society import surface as society_surface

        monkeypatch.setattr("dodaios.society.runtime.current_runtime", lambda: runtime)
        monkeypatch.setattr(society_surface, "current_runtime", lambda: runtime)
        monkeypatch.setattr("dodaios.society.agent_tools.MessageAgentTool", MessageTool)
        svc = AgentChatService(AgentChatStore(), bus=lambda: bus)

        async def isolated_session(sid: str, **_kwargs):
            return svc.store.get_session(sid)

        monkeypatch.setattr(svc, "bind_society_session", isolated_session)
        sid = svc.store.create_session(
            provider="openai",
            model="",
            effort="low",
            cwd=".",
            surface="society",
            session_id="society:mail",
        ).session_id
        request_data = request("message", '@"Drive Agent" First line\nSecond line')
        first = await svc.controls.execute(sid, request_data)
        second = await svc.controls.execute(sid, request_data)
        if environment == "sandbox":
            assert first.status == "failed" and first == second
            assert not calls, "a sandbox agent must not send host-side messages"
            return
        assert first.status == "done" and first == second
        assert len(calls) == 1
        assert calls[0][0] == "mail"
        assert calls[0][1]["target"] == "Drive Agent"
        assert calls[0][1]["text"] == "First line\nSecond line"
        assert first.data["result"]["status"] == "queued"
        assert any(e["kind"] == "tool_result" for e in svc.store.list_events(sid))

    asyncio.run(scenario())


@pytest.mark.parametrize("locale", ["en", "de", "es", "pt"])
def test_command_request_accepts_every_slash_locale(locale: str) -> None:
    # Mirrors ChatCommands.tsx: every interface language with its own slash
    # dictionary sends its code, and the request must not reject it.
    req = CommandRequest(command="status", request_id="r1", locale=locale)
    assert req.locale == locale


def test_command_request_rejects_an_unknown_locale() -> None:
    with pytest.raises(ValueError):
        CommandRequest(command="status", request_id="r1", locale="xx")