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.
Python agent-orchestrationai-agentai-coding-assistantclaude-codecoding-agentcomputer-usedesktop-applocal-firstmcppersonal-jarvisvoice-assistantvoice-coding
"""Binding an agent to its canonical chat; delivering board envelopes into it."""
from __future__ import annotations
import dataclasses
import os
from pathlib import Path
from types import SimpleNamespace
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
from dodaios.agent_chat.store import SURFACES, AgentChatStore
from dodaios.society.chat_binding import ensure_session, frame_incoming, make_deliver_hook
from dodaios.society.events import MsgType, SocietyEnvelope
from dodaios.society.runtime import SocietyRuntime
class FakeService:
from dodaios.agent_chat.service import AgentChatService
receive_message = AgentChatService.receive_message
message_status = AgentChatService.message_status
async def _emit(self, session_id, event):
self.store.append_event(session_id, event)
async def post_notice(self, session_id, payload):
from dodaios.agent_chat.events import make_event
await self._emit(session_id, make_event("notice", payload))
async def cancel(self, _session_id, *, expected_turn_id=None):
self.cancelled_turns.append(expected_turn_id)
return False
async def bind_society_session(self, session_id):
from dodaios.society.chat_binding import bind_society_session
return await bind_society_session(self, session_id)
def __init__(self, store: AgentChatStore) -> None:
self.store = store
self.sent: list[tuple[str, str]] = []
self.busy: set[str] = set()
self.cancelled_turns: list[str | None] = []
def is_running(self, session_id: str) -> bool:
return session_id in self.busy
async def send(self, session_id: str, text: str, attachments=None, *, incoming=None) -> str:
self.sent.append((session_id, text))
return "turn-1"
@pytest.fixture
async def world(tmp_path: Path):
cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
runtime = SocietyRuntime(tmp_path, seed_starter_team=False, cfg=lambda: cfg)
await runtime.ensure_started()
svc = FakeService(AgentChatStore(tmp_path / "agent_chat.db"))
try:
yield runtime, svc, cfg
finally:
await runtime.close()
async def _legacy_agent(rt: SocietyRuntime, agent):
"""Model a saved pre-approval-mode roster row in both stores."""
await rt.store.update_agent(agent.agent_id, {"approval_mode": None})
return dataclasses.replace(agent, approval_mode=None)
def test_society_is_a_surface():
assert "society" in SURFACES
async def test_ensure_session_is_deterministic_and_reseats(world):
rt, svc, cfg = world
scout, _ = await rt.roster.create(name="Scout", provider="openai", model="gpt-5.2")
first = ensure_session(svc, cfg, scout)
assert first.session_id == "society:scout"
assert first.surface == "society"
assert first.provider == "openai" and first.model == "gpt-5.2"
# New agents start on the Society ladder's Bypass default.
assert first.permission_mode == "bypass"
assert first.title == "Scout"
assert Path(first.cwd).name == "workspace" and os.path.isdir(first.cwd) # noqa: ASYNC240
assert Path(first.cwd).is_absolute()
again = ensure_session(svc, cfg, scout)
assert again.session_id == first.session_id
assert len(svc.store.list_sessions(surface="society")) == 1
moved = await rt.roster.update("scout", {"provider": "gemini", "model": "gemini-3-pro"})
reseated = ensure_session(svc, cfg, moved)
assert reseated.provider == "gemini" and reseated.model == "gemini-3-pro"
assert reseated.session_id == "society:scout"
async def test_legacy_ceiling_maps_to_stance(world):
"""A pre-migration row (no approval mode) keeps its ceiling's old stance."""
rt, svc, cfg = world
safe, _ = await rt.roster.create(name="Reader", provider="openai", permission_ceiling="safe")
ask, _ = await rt.roster.create(name="Asker", provider="openai", permission_ceiling="ask")
safe = dataclasses.replace(safe, approval_mode=None)
ask = dataclasses.replace(ask, approval_mode=None)
assert ensure_session(svc, cfg, safe).permission_mode == "plan"
assert ensure_session(svc, cfg, ask).permission_mode == "ask"
async def test_existing_session_follows_roster_permissions_name_and_workspace(world):
rt, svc, cfg = world
agent, _ = await rt.roster.create(name="Scout", provider="openai")
agent = await _legacy_agent(rt, agent)
first = ensure_session(svc, cfg, agent)
updated = await rt.roster.update(
agent.agent_id,
{
"name": "Research Scout",
"permission_ceiling": "safe",
"workspace_dir": "society/scout/research",
},
)
session = ensure_session(svc, cfg, updated)
assert session.session_id == first.session_id
assert session.permission_mode == "plan"
assert session.title == "Research Scout"
assert Path(session.cwd).name == "research"
assert len(svc.store.list_sessions(surface="society")) == 1
async def test_rebinding_preserves_a_more_restrictive_user_stance(world):
rt, svc, cfg = world
agent, _ = await rt.roster.create(name="Scout", provider="openai")
agent = await _legacy_agent(rt, agent)
first = ensure_session(svc, cfg, agent)
assert first.permission_mode == "ask"
svc.store.update_session(first.session_id, permission_mode="plan")
svc.store.set_permission_override(first.session_id, "plan")
assert ensure_session(svc, cfg, agent).permission_mode == "plan"
svc.store.update_session(first.session_id, permission_mode="ask")
svc.store.set_permission_override(first.session_id, "ask")
assert ensure_session(svc, cfg, agent).permission_mode == "ask"
async def test_relaxed_roster_ceiling_restores_default_without_user_override(world):
rt, svc, cfg = world
agent, _ = await rt.roster.create(name="Reader", provider="openai", permission_ceiling="safe")
agent = await _legacy_agent(rt, agent)
first = ensure_session(svc, cfg, agent)
assert first.permission_mode == "plan"
updated = await rt.roster.update(agent.agent_id, {"permission_ceiling": "monitor"})
assert ensure_session(svc, cfg, updated).permission_mode == "accept-edits"
svc.store.set_permission_override(first.session_id, "plan")
assert ensure_session(svc, cfg, updated).permission_mode == "plan"
async def test_chat_route_records_an_explicit_permission_choice(world):
from dodaios.ui.web.agent_chat_routes import router
rt, svc, cfg = world
agent, _ = await rt.roster.create(name="Scout", provider="openai")
session = ensure_session(svc, cfg, agent)
svc.controls = SimpleNamespace(state=lambda _sid: SimpleNamespace(goal=None))
app = FastAPI()
app.include_router(router)
app.state.agent_chat = svc
with TestClient(app) as client:
response = client.patch(
f"/api/agent-chat/sessions/{session.session_id}",
json={"permission_mode": "ask"},
)
stale_model = client.patch(
f"/api/agent-chat/sessions/{session.session_id}",
json={"model": "not-the-roster-model"},
)
assert response.status_code == 200
assert svc.store.permission_override(session.session_id) == "ask"
assert ensure_session(svc, cfg, agent).permission_mode == "ask"
assert stale_model.status_code == 200
assert stale_model.json()["model"] == agent.model
updates = [
event["payload"]
for event in svc.store.list_events(session.session_id)
if event["kind"] == "session_updated"
]
assert {"model": agent.model} in updates
async def test_safe_agent_route_clamps_a_requested_bypass(world):
from dodaios.ui.web.agent_chat_routes import router
rt, svc, cfg = world
agent, _ = await rt.roster.create(name="Reader", provider="openai", permission_ceiling="safe")
agent = await _legacy_agent(rt, agent)
session = ensure_session(svc, cfg, agent)
svc.controls = SimpleNamespace(state=lambda _sid: SimpleNamespace(goal=None))
app = FastAPI()
app.include_router(router)
app.state.agent_chat = svc
with TestClient(app) as client:
response = client.patch(
f"/api/agent-chat/sessions/{session.session_id}",
json={"permission_mode": "bypass"},
)
assert response.status_code == 200
assert response.json()["permission_mode"] == "plan"
assert svc.store.get_session(session.session_id).permission_mode == "plan"
assert svc.store.permission_override(session.session_id) == "plan"
assert any(
event["kind"] == "session_updated" and event["payload"].get("permission_mode") == "plan"
for event in svc.store.list_events(session.session_id)
)
async def test_society_route_rejects_an_unsupported_ask_before_storage(world, monkeypatch):
from dodaios.ui.web import agent_chat_routes
rt, svc, cfg = world
agent, _ = await rt.roster.create(name="Scout", provider="openai")
session = ensure_session(svc, cfg, agent)
monkeypatch.setattr(agent_chat_routes, "resolve_runner", lambda *_args, **_kw: "grok-cli")
app = FastAPI()
app.include_router(agent_chat_routes.router)
app.state.agent_chat = svc
with TestClient(app) as client:
response = client.patch(
f"/api/agent-chat/sessions/{session.session_id}",
json={"permission_mode": "ask"},
)
assert response.status_code == 422
assert svc.store.permission_override(session.session_id) == ""
assert svc.store.get_session(session.session_id).permission_mode == "bypass"
async def test_society_patch_does_not_reseat_if_a_turn_starts_during_cleanup(world):
from dodaios.ui.web.agent_chat_routes import router
rt, svc, cfg = world
agent, _ = await rt.roster.create(name="Scout", provider="openai")
session = ensure_session(svc, cfg, agent)
async def begin_turn(_session_id):
svc.busy.add(session.session_id)
svc.controls = SimpleNamespace(
state=lambda _sid: SimpleNamespace(goal=None),
_clear_saved_native=begin_turn,
)
app = FastAPI()
app.include_router(router)
app.state.agent_chat = svc
with TestClient(app) as client:
response = client.patch(
f"/api/agent-chat/sessions/{session.session_id}",
json={"provider": "gemini"},
)
assert response.status_code == 409
assert svc.store.get_session(session.session_id).provider == "openai"
async def test_direct_send_rebinds_safe_agent_before_runner(tmp_path: Path):
from dodaios.agent_chat.service import AgentChatService
store = AgentChatStore(tmp_path / "agent_chat.db")
svc = AgentChatService(store, assistant_name=lambda: "Test")
cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
rt = SocietyRuntime(
tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
)
await rt.ensure_started()
try:
agent, _ = await rt.roster.create(
name="Reader", provider="openai", permission_ceiling="safe"
)
agent = await _legacy_agent(rt, agent)
session = ensure_session(svc, cfg, agent)
store.update_session(session.session_id, permission_mode="bypass")
store.set_permission_override(session.session_id, "bypass")
observed: list[str] = []
async def capture(handle, _text):
observed.append(handle.session.permission_mode)
await svc.send(
session.session_id,
"Read the note",
control_runner=capture,
control_owned=True,
direct_user=False,
)
await svc.wait_turn(session.session_id)
assert observed == ["plan"]
assert store.get_session(session.session_id).permission_mode == "plan"
finally:
await svc.cancel_all()
await rt.close()
async def test_routine_chat_rejects_direct_messages_and_inactive_owner(tmp_path: Path):
from dodaios.agent_chat.service import AgentChatService
from dodaios.ui.web.agent_chat_routes import router
store = AgentChatStore(tmp_path / "agent_chat.db")
svc = AgentChatService(store, assistant_name=lambda: "Test")
cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
rt = SocietyRuntime(
tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
)
await rt.ensure_started()
try:
agent, _ = await rt.roster.create(name="Scout", provider="openai")
routine = store.create_session(
session_id=f"{agent.session_id}:routine:task-1:run-1",
surface="society",
provider="openai",
model="",
effort="low",
cwd=str(tmp_path),
permission_mode="bypass",
)
app = FastAPI()
app.include_router(router)
app.state.agent_chat = svc
with TestClient(app) as client:
response = client.post(
f"/api/agent-chat/sessions/{routine.session_id}/messages",
json={"text": "Do something unrelated"},
)
assert response.status_code == 403
assert store.list_events(routine.session_id) == []
await rt.roster.update(agent.agent_id, {"state": "paused"})
with pytest.raises(PermissionError, match="active scheduled run"):
await svc.send(
routine.session_id, "Scheduled task", direct_user=False, routine_run=True
)
finally:
await svc.cancel_all()
await rt.close()
async def test_busy_turn_defers_provider_reseat_until_it_finishes(tmp_path: Path):
import asyncio
from dodaios.agent_chat.control_types import CommandRequest
from dodaios.agent_chat.service import AgentChatService, SessionBusy
store = AgentChatStore(tmp_path / "agent_chat.db")
svc = AgentChatService(store, assistant_name=lambda: "Test")
cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
rt = SocietyRuntime(
tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
)
await rt.ensure_started()
started = asyncio.Event()
release = asyncio.Event()
try:
agent, _ = await rt.roster.create(name="Scout", provider="openai", model="old")
session = ensure_session(svc, cfg, agent)
async def held_runner(_handle, _text):
started.set()
await release.wait()
return "old-vendor-session"
await svc.send(
session.session_id,
"First task",
control_runner=held_runner,
control_owned=True,
direct_user=False,
)
await asyncio.wait_for(started.wait(), timeout=3)
await rt.roster.update(agent.agent_id, {"provider": "gemini", "model": "new"})
with pytest.raises(SessionBusy):
await svc.send(session.session_id, "Second task")
command = await svc.controls.execute(
session.session_id, CommandRequest(command="status", request_id="busy-status")
)
assert command.status == "done"
assert command.data["running"] is True
assert store.get_session(session.session_id).provider == "openai"
release.set()
await svc.wait_turn(session.session_id)
assert store.get_session(session.session_id).vendor_session == "old-vendor-session"
moved = await svc.bind_society_session(session.session_id)
assert moved.provider == "gemini" and moved.model == "new"
assert moved.vendor_session == ""
finally:
release.set()
await svc.cancel_all()
await rt.close()
async def test_an_older_side_chat_is_read_only(tmp_path: Path):
"""Side chats from before the one-chat change stay readable, never run."""
from dodaios.agent_chat.service import AgentChatService
store = AgentChatStore(tmp_path / "agent_chat.db")
svc = AgentChatService(store, assistant_name=lambda: "Test")
cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
rt = SocietyRuntime(
tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
)
await rt.ensure_started()
try:
agent, _ = await rt.roster.create(name="Scout", provider="openai")
legacy = store.create_session(
session_id=f"{agent.session_id}:with:jarvis", surface="society",
provider="openai", model="", effort="", cwd=str(tmp_path),
permission_mode="bypass", title="Scout · Jarvis",
)
with pytest.raises(PermissionError, match="read-only"):
await svc.bind_society_session(legacy.session_id)
chat = ensure_session(svc, cfg, agent)
assert chat.session_id == agent.session_id
assert (await svc.bind_society_session(chat.session_id)).session_id == agent.session_id
finally:
await svc.cancel_all()
await rt.close()
async def test_routine_turn_does_not_reserve_direct_chat_seat(tmp_path: Path):
import asyncio
from dodaios.agent_chat.service import AgentChatService
store = AgentChatStore(tmp_path / "agent_chat.db")
svc = AgentChatService(store, assistant_name=lambda: "Test")
cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
rt = SocietyRuntime(
tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
)
await rt.ensure_started()
entered = asyncio.Event()
release = asyncio.Event()
try:
agent, _ = await rt.roster.create(name="Scout", provider="openai")
direct = ensure_session(svc, cfg, agent)
routine = store.create_session(
session_id=f"{agent.session_id}:routine:task-1:run-1",
surface="society", provider="openai", model="", effort="low",
cwd=direct.cwd, permission_mode="bypass",
)
async def held_runner(_handle, _text):
entered.set()
await release.wait()
await svc.send(
direct.session_id, "Direct task", control_runner=held_runner,
control_owned=True, direct_user=False,
)
await asyncio.wait_for(entered.wait(), timeout=3)
await svc.send(
routine.session_id, "Scheduled task", control_runner=held_runner,
control_owned=True, direct_user=False, routine_run=True,
)
assert svc.is_running(direct.session_id)
assert svc.is_running(routine.session_id)
finally:
release.set()
await svc.cancel_all()
await rt.close()
async def test_build_cannot_raise_a_safe_agent_above_its_ceiling(world):
from dodaios.agent_chat.control import ChatControls
from dodaios.agent_chat.control_types import CommandRequest
rt, svc, cfg = world
agent, _ = await rt.roster.create(name="Scout", provider="openai")
agent = await _legacy_agent(rt, agent)
session = ensure_session(svc, cfg, agent)
controls = ChatControls(svc, adapters=[])
svc.controls = controls
plan = await controls.execute(
session.session_id, CommandRequest(command="plan", request_id="plan-1")
)
assert plan.status == "done"
updated = await rt.roster.update(agent.agent_id, {"permission_ceiling": "safe"})
assert updated.permission_ceiling == "safe"
build = await controls.execute(
session.session_id, CommandRequest(command="build", request_id="build-1")
)
assert build.status == "failed"
assert svc.store.get_session(session.session_id).permission_mode == "plan"
assert svc.store.permission_override(session.session_id) == "plan"
async def test_build_sees_a_relaxed_roster_ceiling_before_checking_plan(world):
from dodaios.agent_chat.control import ChatControls
from dodaios.agent_chat.control_types import CommandRequest
rt, svc, cfg = world
agent, _ = await rt.roster.create(name="Reader", provider="openai", permission_ceiling="safe")
agent = await _legacy_agent(rt, agent)
session = ensure_session(svc, cfg, agent)
controls = ChatControls(svc, adapters=[])
svc.controls = controls
await rt.roster.update(agent.agent_id, {"permission_ceiling": "monitor"})
result = await controls.execute(
session.session_id, CommandRequest(command="build", request_id="build-after-roster")
)
assert result.status == "done"
assert svc.store.get_session(session.session_id).permission_mode == "ask"
async def test_provider_change_with_default_model_discards_old_provider_model(world):
rt, svc, cfg = world
agent, _ = await rt.roster.create(name="Scout", provider="openai", model="gpt-5.2")
first = ensure_session(svc, cfg, agent)
assert first.model == "gpt-5.2"
updated = await rt.roster.update(agent.agent_id, {"provider": "gemini", "model": ""})
session = ensure_session(svc, cfg, updated)
assert session.provider == "gemini"
assert session.model == ""
assert session.session_id == first.session_id
async def test_explicit_approval_mode_wins(world):
rt, svc, cfg = world
asker, _ = await rt.roster.create(name="Asker", provider="openai")
asker = await rt.roster.update("asker", {"approval_mode": "ask"})
assert ensure_session(svc, cfg, asker).permission_mode == "ask"
async def test_explicit_chat_mode_stays_separate_from_tool_ceiling(world):
rt, svc, cfg = world
agent, _ = await rt.roster.create(
name="Reader", provider="openai", permission_ceiling="safe"
)
session = ensure_session(svc, cfg, agent)
assert session.permission_mode == "bypass"
agent = await rt.roster.update(agent.agent_id, {"approval_mode": "ask"})
assert ensure_session(svc, cfg, agent).permission_mode == "ask"
svc.store.set_permission_override(session.session_id, "always_ask")
assert ensure_session(svc, cfg, agent).permission_mode == "always_ask"
async def test_legacy_ask_agent_refuses_runner_without_actionable_approvals(world, monkeypatch):
rt, svc, cfg = world
agent, _ = await rt.roster.create(name="Legacy", provider="openai")
agent = await _legacy_agent(rt, agent)
monkeypatch.setattr(
"dodaios.agent_chat.service.resolve_runner", lambda *_args, **_kw: "grok-cli"
)
with pytest.raises(PermissionError, match="actionable approval"):
ensure_session(svc, cfg, agent)
assert svc.store.get_session(agent.session_id) is None
@pytest.mark.parametrize("blocked_by", ["paused", "kill_switch"])
async def test_inactive_agent_cannot_bind_canonical_chat(world, blocked_by):
from dodaios.society.chat_binding import bind_society_session
rt, svc, cfg = world
agent, _ = await rt.roster.create(name="Scout", provider="openai")
ensure_session(svc, cfg, agent)
if blocked_by == "paused":
await rt.roster.update(agent.agent_id, {"state": "paused"})
else:
await rt.store.set_kill_switch(True)
with pytest.raises(PermissionError, match="paused or disabled"):
await bind_society_session(svc, agent.session_id)
@pytest.mark.parametrize(
("blocked_by", "active_goal"), [("paused", True), ("kill_switch", False)]
)
async def test_live_roster_change_during_pre_admission_await_blocks_turn(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch, blocked_by: str, active_goal: bool,
):
import asyncio
from dodaios.agent_chat.control_types import GoalState
from dodaios.agent_chat.service import AgentChatService
store = AgentChatStore(tmp_path / "agent_chat.db")
svc = AgentChatService(store, assistant_name=lambda: "Test")
cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
rt = SocietyRuntime(
tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
)
await rt.ensure_started()
entered = asyncio.Event()
release = asyncio.Event()
sending = None
try:
agent, _ = await rt.roster.create(name="Scout", provider="openai")
session = ensure_session(svc, cfg, agent)
controls = svc.controls
if active_goal:
state = controls.state(session.session_id)
state.goal = GoalState(
id="goal-1", objective="Keep the task", started_ms=1, updated_ms=1
)
controls.store.save(state)
original_get = rt.roster.get
calls = 0
async def held_second_roster_read(agent_id):
nonlocal calls
calls += 1
if calls == 2:
entered.set()
await release.wait()
return await original_get(agent_id)
monkeypatch.setattr(rt.roster, "get", held_second_roster_read)
async def fake_runner(_handle, _text):
pytest.fail("a disabled Society agent must never start paid work")
sending = asyncio.create_task(
svc.send(session.session_id, "Task", control_runner=fake_runner)
)
await asyncio.wait_for(entered.wait(), timeout=3)
assert controls.state(session.session_id).last_status == "running"
if blocked_by == "paused":
await rt.roster.update(agent.agent_id, {"state": "paused"})
else:
await rt.store.set_kill_switch(True)
release.set()
with pytest.raises(PermissionError, match="paused or disabled"):
await sending
assert not svc.is_running(session.session_id)
state = controls.state(session.session_id)
assert state.last_status == ("interrupted" if active_goal else "failed")
if active_goal:
assert state.goal is not None
assert state.goal.status == "paused"
assert state.goal.objective == "Keep the task"
assert not any(
event["kind"] in ("user_message", "turn_started")
for event in store.list_events(session.session_id)
)
finally:
release.set()
if sending is not None and not sending.done():
sending.cancel()
await asyncio.gather(sending, return_exceptions=True)
await svc.cancel_all()
await rt.close()
async def test_final_society_rebind_keeps_read_only_turn_override(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
):
import asyncio
from dodaios.agent_chat.service import AgentChatService
store = AgentChatStore(tmp_path / "agent_chat.db")
svc = AgentChatService(store, assistant_name=lambda: "Test")
cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
rt = SocietyRuntime(
tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
)
await rt.ensure_started()
entered = asyncio.Event()
release = asyncio.Event()
observed: list[tuple[str, str]] = []
async def held_control_message(_sid, _text):
entered.set()
await release.wait()
monkeypatch.setattr(svc.controls, "user_message", held_control_message)
try:
agent, _ = await rt.roster.create(name="Scout", provider="openai")
session = ensure_session(svc, cfg, agent)
async def fake_runner(handle, _text):
observed.append((handle.session.permission_mode, handle.stance))
sending = asyncio.create_task(
svc.send(session.session_id, "Read only task", read_only=True,
control_runner=fake_runner)
)
await asyncio.wait_for(entered.wait(), timeout=3)
release.set()
await sending
await svc.wait_turn(session.session_id)
assert observed == [("plan", "plan")]
assert store.get_session(session.session_id).permission_mode == "bypass"
finally:
release.set()
await svc.cancel_all()
await rt.close()
async def test_two_sends_cannot_replace_pre_admission_control_owner(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
):
import asyncio
from dodaios.agent_chat.events import make_event
from dodaios.agent_chat.service import AgentChatService, SessionBusy
store = AgentChatStore(tmp_path / "agent_chat.db")
svc = AgentChatService(store, assistant_name=lambda: "Test")
cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
rt = SocietyRuntime(
tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
)
await rt.ensure_started()
entered = asyncio.Event()
release = asyncio.Event()
finished = asyncio.Event()
sending = None
try:
agent, _ = await rt.roster.create(name="Scout", provider="openai")
session = ensure_session(svc, cfg, agent)
controls = svc.controls
original_completed = controls.turn_completed
async def mark_completed(*args):
await original_completed(*args)
finished.set()
monkeypatch.setattr(controls, "turn_completed", mark_completed)
original_get = rt.roster.get
calls = 0
async def held_second_roster_read(agent_id):
nonlocal calls
calls += 1
if calls == 2:
entered.set()
await release.wait()
return await original_get(agent_id)
monkeypatch.setattr(rt.roster, "get", held_second_roster_read)
async def fake_runner(handle, _text):
await handle.emit(make_event(
"turn_finished", {"turn_id": handle.turn_id, "status": "done"}
))
sending = asyncio.create_task(
svc.send(session.session_id, "Task A", control_runner=fake_runner)
)
await asyncio.wait_for(entered.wait(), timeout=3)
assert controls.state(session.session_id).last_request == "Task A"
with pytest.raises(SessionBusy):
await svc.send(session.session_id, "Task B", control_runner=fake_runner)
assert controls.state(session.session_id).last_request == "Task A"
release.set()
await sending
await asyncio.wait_for(finished.wait(), timeout=3)
state = controls.state(session.session_id)
assert state.last_request == "Task A"
assert state.last_status == "done"
assert not any(
event["kind"] == "user_message"
and event["payload"].get("text") == "Task B"
for event in store.list_events(session.session_id)
)
finally:
release.set()
if sending is not None and not sending.done():
sending.cancel()
await asyncio.gather(sending, return_exceptions=True)
await svc.cancel_all()
await rt.close()
async def test_stop_during_final_roster_lookup_prevents_a_runner(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
):
import asyncio
from dodaios.agent_chat.service import AgentChatService
store = AgentChatStore(tmp_path / "agent_chat.db")
svc = AgentChatService(store, assistant_name=lambda: "Test")
cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
rt = SocietyRuntime(
tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
)
await rt.ensure_started()
entered = asyncio.Event()
release = asyncio.Event()
sending = None
try:
agent, _ = await rt.roster.create(name="Scout", provider="openai")
session = ensure_session(svc, cfg, agent)
controls = svc.controls
original_get = rt.roster.get
calls = 0
async def held_second_roster_read(agent_id):
nonlocal calls
calls += 1
if calls == 2:
entered.set()
await release.wait()
return await original_get(agent_id)
monkeypatch.setattr(rt.roster, "get", held_second_roster_read)
async def fake_runner(_handle, _text):
pytest.fail("Stop must prevent the runner from starting")
sending = asyncio.create_task(
svc.send(session.session_id, "Task", control_runner=fake_runner)
)
await asyncio.wait_for(entered.wait(), timeout=3)
assert controls.state(session.session_id).last_status == "running"
assert svc.is_running(session.session_id)
await controls.pause(session.session_id, "Stopped by the user")
release.set()
with pytest.raises(asyncio.CancelledError):
await sending
assert not svc.is_running(session.session_id)
assert controls.state(session.session_id).last_status == "interrupted"
assert not any(
event["kind"] == "turn_started"
for event in store.list_events(session.session_id)
)
finally:
release.set()
if sending is not None and not sending.done():
sending.cancel()
await asyncio.gather(sending, return_exceptions=True)
await svc.cancel_all()
await rt.close()
async def test_roster_mode_edit_defers_busy_chat_and_preserves_override(world, monkeypatch):
from dodaios.ui.web.society_routes import router
rt, svc, cfg = world
monkeypatch.setattr(rt, "_get_chat", lambda: svc)
agent, _ = await rt.roster.create(name="Scout", provider="openai", approval_mode="ask")
session = ensure_session(svc, cfg, agent)
svc.store.set_permission_override(session.session_id, "always_ask")
assert ensure_session(svc, cfg, agent).permission_mode == "always_ask"
svc.busy.add(session.session_id)
app = FastAPI()
app.include_router(router)
app.state.society = rt
with TestClient(app) as client:
response = client.patch(
f"/api/society/agents/{agent.agent_id}",
json={"approval_mode": "bypass"},
)
assert response.status_code == 200, response.text
assert svc.store.get_session(session.session_id).permission_mode == "always_ask"
svc.busy.remove(session.session_id)
updated = await rt.roster.get(agent.agent_id)
assert ensure_session(svc, cfg, updated).permission_mode == "always_ask"
@pytest.mark.parametrize(
("method", "suffix", "payload"),
[
("POST", "/model", {"provider": "grok", "model": "grok-test"}),
("PATCH", "", {"provider": "grok"}),
],
)
async def test_runner_change_rejects_incompatible_chat_override(
world, monkeypatch, method, suffix, payload
):
from dodaios.ui.web.society_routes import router
rt, svc, cfg = world
monkeypatch.setattr(rt, "_get_chat", lambda: svc)
agent, _ = await rt.roster.create(name="Scout", provider="openai")
session = ensure_session(svc, cfg, agent)
svc.store.set_permission_override(session.session_id, "always_ask")
assert ensure_session(svc, cfg, agent).permission_mode == "always_ask"
monkeypatch.setattr(
"dodaios.agent_chat.service.resolve_runner",
lambda provider, **_kw: "grok-cli" if provider == "grok" else "brain",
)
app = FastAPI()
app.include_router(router)
app.state.society = rt
with TestClient(app) as client:
response = client.request(
method,
f"/api/society/agents/{agent.agent_id}{suffix}",
json=payload,
)
assert response.status_code == 422
assert (await rt.roster.get(agent.agent_id)).provider == "openai"
assert svc.store.get_session(session.session_id).provider == "openai"
async def test_without_provider_the_agents_tier_answers(world, monkeypatch):
rt, svc, cfg = world
import dodaios.local_models.assistant_session as tier_mod
monkeypatch.setattr(
tier_mod,
"agents_tier",
lambda cfg, **kw: SimpleNamespace(provider="grok", model="grok-5", ready=True, reason=""),
)
scout, _ = await rt.roster.create(name="Scout")
session = ensure_session(svc, cfg, scout)
assert session.provider == "grok" and session.model == "grok-5"
monkeypatch.setattr(
tier_mod,
"agents_tier",
lambda cfg, **kw: SimpleNamespace(provider="", model="", ready=False, reason="no key"),
)
quill, _ = await rt.roster.create(name="Quill")
with pytest.raises(PermissionError):
ensure_session(svc, cfg, quill)
async def test_deliver_hook_frames_and_sends(world):
rt, svc, cfg = world
scout, _ = await rt.roster.create(name="Scout", provider="openai")
deliver = make_deliver_hook(lambda: svc, lambda: cfg, resolve_name=lambda a: a.title())
env = SocietyEnvelope(
msg_type=MsgType.QUERY,
from_agent="archivist",
to_agent="scout",
trace_id="t",
payload={"text": "Where is the VPS note?", "refs": ["wiki:society/archivist/vps.md"]},
)
await deliver(scout, env)
# A teammate's message runs in Scout's one chat, as a delegation card.
assert svc.sent == [
(
"society:scout",
"[query from Archivist]\nWhere is the VPS note?\nRefs: wiki:society/archivist/vps.md\n"
f"Message id: {env.event_id}; sender id: archivist\n"
"Reply expectation: always. Answer with society_message_agent kind 'answer' "
"(reply_status=blocked if you cannot).",
)
]
assert svc.store.get_session("society:scout:with:archivist") is None
assert svc.store.get_session("society:scout").title == "Scout"
svc.busy.add("society:scout")
with pytest.raises(RuntimeError, match="target busy"):
await deliver(scout, env)
def test_result_frame_carries_the_handoff():
env = SocietyEnvelope(
msg_type=MsgType.RESULT,
from_agent="scout",
to_agent="archivist",
trace_id="t",
payload={
"status": "partial",
"done": "Found three providers.",
"output": ["wiki:society/scout/vps.md"],
"open": ["pricing for the 4 GB tier"],
},
)
text = frame_incoming(env, "Scout")
assert text.splitlines()[:5] == [
"[result from Scout]",
"Status: partial",
"Done: Found three providers.",
"Output: wiki:society/scout/vps.md",
"Open: pricing for the 4 GB tier",
]
async def test_scheduler_delivers_through_the_hook(world):
rt, svc, cfg = world
await rt.roster.create(name="Scout", provider="openai")
await rt.roster.create(name="Archivist", provider="openai")
rt.set_deliver(make_deliver_hook(lambda: svc, lambda: cfg))
await rt.say(from_agent="scout", to_agent="archivist", text="ping")
assert [s[0] for s in svc.sent] == ["society:archivist"]
assert svc.sent[0][1].startswith("[say from Scout]")
def test_unfiltered_session_list_hides_society_sessions(tmp_path: Path):
from dodaios.ui.web.agent_chat_routes import router
store = AgentChatStore(tmp_path / "agent_chat.db")
store.create_session(provider="openai", model="m", effort="", cwd="", surface="agent")
store.create_session(
provider="openai", model="m", effort="", cwd="", surface="society", session_id="society:x"
)
app = FastAPI()
app.include_router(router)
app.state.agent_chat = SimpleNamespace(
store=store, is_running=lambda sid: False, pending_approvals=lambda sid: []
)
with TestClient(app) as c:
everything = c.get("/api/agent-chat/sessions").json()["sessions"]
assert [s["surface"] for s in everything] == ["agent"]
only = c.get("/api/agent-chat/sessions", params={"surface": "society"}).json()["sessions"]
assert [s["session_id"] for s in only] == ["society:x"]
class FakeTurnService(FakeService):
"""A service whose turns end: the watcher must write a RESULT and free the slot."""
def __init__(self, store: AgentChatStore) -> None:
super().__init__(store)
self.queues: dict[str, list] = {}
def subscribe(self, session_id: str):
import asyncio
q = asyncio.Queue()
self.queues.setdefault(session_id, []).append(q)
return q
def unsubscribe(self, session_id: str, q) -> None:
subscribers = self.queues.get(session_id, [])
if q in subscribers:
subscribers.remove(q)
async def send(self, session_id: str, text: str, attachments=None, *, incoming=None) -> str:
self.sent.append((session_id, text))
# A sent turn runs until it finishes, as in the real service: the
# watcher must not take a quiet but live turn for one that has ended.
self.busy.add(session_id)
return "turn-1"
async def finish(self, session_id: str, text: str, *, status: str = "ok") -> None:
self.busy.discard(session_id)
for q in list(self.queues.get(session_id, [])):
q.put_nowait({"kind": "assistant_text", "payload": {"turn_id": "turn-1", "text": text}})
q.put_nowait(
{"kind": "turn_finished", "payload": {"turn_id": "turn-1", "status": status}}
)
async def test_assign_runs_in_the_canonical_chat_and_ends_as_a_result(tmp_path: Path):
import asyncio
svc = FakeTurnService(AgentChatStore(tmp_path / "agent_chat.db"))
cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
rt = SocietyRuntime(
tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
)
await rt.ensure_started()
try:
await rt.roster.create(name="Scout", provider="openai", model="gpt-5.2")
env = await rt.say(
from_agent="user", to_agent="scout", text="Find the best VPS.", msg_type=MsgType.ASSIGN
)
# The assignment became a framed chat turn on Scout's own session.
assert svc.sent[0][0] == "society:scout"
assert svc.sent[0][1].startswith("[assignment from the user]\nFind the best VPS.")
assert "handoff" in svc.sent[0][1]
assert rt.scheduler.running == {"turn:turn-1": "scout"}
await svc.finish("society:scout", "Hetzner CX22 wins. Done.")
await asyncio.sleep(0.05)
assert rt.scheduler.running == {}
thread = await rt.store.events_for_trace(env.trace_id)
assert [e.msg_type for e in thread] == [MsgType.ASSIGN, MsgType.CLAIM, MsgType.RESULT]
result = thread[-1]
assert result.from_agent == "scout" and result.payload["status"] == "done"
assert result.payload["done"] == "Hetzner CX22 wins. Done."
assert result.payload["output"] == ["chat:society:scout"]
finally:
await rt.close()
async def test_failed_turn_becomes_a_blocked_result(tmp_path: Path):
import asyncio
svc = FakeTurnService(AgentChatStore(tmp_path / "agent_chat.db"))
cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
rt = SocietyRuntime(
tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
)
await rt.ensure_started()
try:
await rt.roster.create(name="Scout", provider="openai")
env = await rt.say(from_agent="user", to_agent="scout", text="x", msg_type=MsgType.ASSIGN)
await svc.finish("society:scout", "", status="error")
await asyncio.sleep(0.05)
result = (await rt.store.events_for_trace(env.trace_id))[-1]
assert result.msg_type is MsgType.RESULT and result.payload["status"] == "blocked"
assert result.payload["open"]
finally:
await rt.close()
async def test_a_picture_that_could_not_be_shown_does_not_block_finished_work(tmp_path: Path):
"""Live 2026-10-02: Scout's finished research came back "blocked" because
two screenshots it mentioned could not be displayed in its chat."""
import asyncio
svc = FakeTurnService(AgentChatStore(tmp_path / "agent_chat.db"))
cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
rt = SocietyRuntime(
tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
)
await rt.ensure_started()
try:
await rt.roster.create(name="Scout", provider="openai")
env = await rt.say(from_agent="user", to_agent="scout", text="x", msg_type=MsgType.ASSIGN)
for q in list(svc.queues["society:scout"]):
for kind, payload in (
("assistant_text", {"text": "Research done: three findings."}),
("assistant_text", {"text": "", "media_only": True}),
("error", {"message": "Media could not be displayed: a.png",
"display_only": True}),
("turn_finished", {"status": "ok"}),
):
q.put_nowait({"kind": kind, "payload": {"turn_id": "turn-1", **payload}})
await asyncio.sleep(0.05)
result = (await rt.store.events_for_trace(env.trace_id))[-1]
assert result.msg_type is MsgType.RESULT
assert result.payload["status"] == "done"
assert result.payload["done"] == "Research done: three findings."
finally:
await rt.close()
async def test_empty_successful_turn_does_not_claim_task_completion(tmp_path: Path):
import asyncio
svc = FakeTurnService(AgentChatStore(tmp_path / "agent_chat.db"))
cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
rt = SocietyRuntime(
tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
)
await rt.ensure_started()
try:
await rt.roster.create(name="Scout", provider="openai")
env = await rt.say(from_agent="user", to_agent="scout", text="x", msg_type=MsgType.ASSIGN)
await svc.finish("society:scout", "")
await asyncio.sleep(0.05)
result = (await rt.store.events_for_trace(env.trace_id))[-1]
assert result.msg_type is MsgType.RESULT
assert result.payload["status"] == "blocked"
assert result.payload["open"] == ["Agent finished without a result report."]
finally:
await rt.close()
async def test_lost_subscriber_recovers_the_durable_turn_result(tmp_path: Path, monkeypatch):
import asyncio
import dodaios.society.runtime as runtime_module
from dodaios.agent_chat.events import make_event
monkeypatch.setattr(runtime_module, "_WATCH_EVENT_POLL_SECONDS", 0.01)
svc = FakeTurnService(AgentChatStore(tmp_path / "agent_chat.db"))
cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
rt = SocietyRuntime(
tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
)
await rt.ensure_started()
try:
await rt.roster.create(name="Scout", provider="openai")
env = await rt.say(
from_agent="user", to_agent="scout", text="Find the answer", msg_type=MsgType.ASSIGN
)
# A full subscriber queue is detached by the service. The terminal
# event still lives in the chat store but never reaches this queue.
svc.queues["society:scout"].clear()
svc.store.append_event(
"society:scout",
make_event("assistant_text", {"turn_id": "turn-1", "text": "Found the answer."}),
)
svc.store.append_event(
"society:scout",
make_event("turn_finished", {"turn_id": "turn-1", "status": "done"}),
)
for _ in range(20):
thread = await rt.store.events_for_trace(env.trace_id)
if thread[-1].msg_type is MsgType.RESULT:
break
await asyncio.sleep(0.01)
else:
pytest.fail("watcher did not recover the durable terminal event")
assert thread[-1].payload["status"] == "done"
assert thread[-1].payload["done"] == "Found the answer."
assert rt.scheduler.running == {}
finally:
await rt.close()
async def test_turn_that_ends_without_a_terminal_event_releases_the_slot(
tmp_path: Path, monkeypatch
):
import asyncio
import dodaios.society.runtime as runtime_module
from dodaios.agent_chat.events import make_event
monkeypatch.setattr(runtime_module, "_WATCH_EVENT_POLL_SECONDS", 0.01)
svc = FakeTurnService(AgentChatStore(tmp_path / "agent_chat.db"))
cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
rt = SocietyRuntime(
tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
)
await rt.ensure_started()
try:
await rt.roster.create(name="Scout", provider="openai")
env = await rt.say(
from_agent="user", to_agent="scout", text="Find the answer", msg_type=MsgType.ASSIGN
)
svc.busy.add("society:scout") # The turn is running...
for q in svc.queues["society:scout"]:
q.put_nowait(make_event("assistant_text", {"turn_id": "turn-1", "text": "Halfway."}))
await asyncio.sleep(0.08)
thread = await rt.store.events_for_trace(env.trace_id)
assert thread[-1].msg_type is MsgType.CLAIM, "a live turn is waited for, however quiet"
svc.busy.discard("society:scout") # ...and its task ends without turn_finished.
for _ in range(50):
thread = await rt.store.events_for_trace(env.trace_id)
if thread[-1].msg_type is MsgType.RESULT:
break
await asyncio.sleep(0.01)
else:
pytest.fail("watcher kept waiting for a turn that no longer runs")
assert thread[-1].payload["status"] == "blocked"
assert thread[-1].payload["open"] == [
"The agent's turn ended without reporting a result."
]
assert rt.scheduler.running == {}
finally:
await rt.close()
async def test_durable_read_failure_releases_the_agent_slot(tmp_path: Path, monkeypatch):
import asyncio
import dodaios.society.runtime as runtime_module
monkeypatch.setattr(runtime_module, "_WATCH_EVENT_POLL_SECONDS", 0.01)
svc = FakeTurnService(AgentChatStore(tmp_path / "agent_chat.db"))
cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
rt = SocietyRuntime(
tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
)
await rt.ensure_started()
try:
await rt.roster.create(name="Scout", provider="openai")
env = await rt.say(
from_agent="user", to_agent="scout", text="Find the answer", msg_type=MsgType.ASSIGN
)
svc.queues["society:scout"].clear()
def unreadable(_session_id, *, after_seq=0):
raise OSError("chat history unavailable")
monkeypatch.setattr(svc.store, "list_events", unreadable)
for _ in range(30):
thread = await rt.store.events_for_trace(env.trace_id)
if thread[-1].msg_type is MsgType.RESULT:
break
await asyncio.sleep(0.01)
else:
pytest.fail("watcher did not release the slot after durable read failure")
assert thread[-1].payload["status"] == "blocked"
assert thread[-1].payload["open"] == [
"Agent result could not be recovered from chat history."
]
assert svc.cancelled_turns == ["turn-1"]
assert rt.scheduler.running == {}
finally:
await rt.close()
async def test_a_picture_that_could_not_be_shown_does_not_block_finished_work(tmp_path: Path):
"""Live 2026-10-02: Scout's finished research came back "blocked" because
two screenshots it mentioned could not be displayed in its chat."""
import asyncio
svc = FakeTurnService(AgentChatStore(tmp_path / "agent_chat.db"))
cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
rt = SocietyRuntime(
tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
)
await rt.ensure_started()
try:
await rt.roster.create(name="Scout", provider="openai")
env = await rt.say(from_agent="user", to_agent="scout", text="x", msg_type=MsgType.ASSIGN)
for q in list(svc.queues["society:scout"]):
for kind, payload in (
("assistant_text", {"text": "Research done: three findings."}),
("assistant_text", {"text": "", "media_only": True}),
("error", {"message": "Media could not be displayed: a.png",
"display_only": True}),
("turn_finished", {"status": "ok"}),
):
q.put_nowait({"kind": kind, "payload": {"turn_id": "turn-1", **payload}})
await asyncio.sleep(0.05)
result = (await rt.store.events_for_trace(env.trace_id))[-1]
assert result.msg_type is MsgType.RESULT
assert result.payload["status"] == "done"
assert result.payload["done"] == "Research done: three findings."
finally:
await rt.close()