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
"""Deterministic tests for browser contracts and policy boundaries."""
from types import SimpleNamespace
import pytest
from dodaios.society.browser.bridge import brain_messages
from dodaios.society.capabilities import (
build_catalog,
capability_id_for_tool,
tool_name_for_capability,
)
from dodaios.ui.web.society_browser_routes import validate_control
def test_browser_capability_roundtrip():
assert capability_id_for_tool("society_browser") == "core:browser"
assert tool_name_for_capability("core:browser") == "society_browser"
rows = build_catalog(
{"society_browser": SimpleNamespace(description="Browse", risk_tier="monitor")}
)
assert "browser-use" in rows[0].aliases
assert "chrome" in rows[0].aliases
assert rows[0].label == "Chrome / Browser"
@pytest.mark.parametrize("platform", ["win32", "darwin", "linux"])
def test_native_window_probe_degrades_without_native_dependencies(monkeypatch, platform):
import importlib.util
from dodaios.society.browser import native_window
monkeypatch.setattr(native_window.sys, "platform", platform)
monkeypatch.setattr(importlib.util, "find_spec", lambda _: None)
assert native_window.available() is False
def test_add_menu_names_the_browser_as_chrome():
from dodaios.agent_chat.tool_catalog import build_catalog, keyword_rank
rows = build_catalog(
{"society_browser": SimpleNamespace(description="Browse websites", risk_tier="monitor")}
)
row = next(row for row in rows if row.id == "tool:society_browser")
assert row.label == "Chrome / Browser"
assert keyword_rank("chrome", row) is not None
assert keyword_rank("browser", row) is not None
async def test_cold_browser_start_emits_progress_until_subscription_ready():
import asyncio
from dodaios.ui.web.society_browser_routes import _subscribe_with_progress
ready = asyncio.Event()
messages = []
subscription = (object(), object())
async def subscribe(_):
await ready.wait()
return subscription
async def send(event):
messages.append(event)
if len(messages) == 2:
ready.set()
result = await asyncio.wait_for(
_subscribe_with_progress(SimpleNamespace(subscribe=subscribe), object(), send), 4
)
assert result is subscription
assert messages == [{"kind": "starting"}, {"kind": "starting"}]
async def test_starting_viewer_transport_failure_cancels_subscription():
import asyncio
from dodaios.ui.web.society_browser_routes import _subscribe_with_progress
cancelled = asyncio.Event()
sends = 0
async def subscribe(_):
try:
await asyncio.Event().wait()
finally:
cancelled.set()
async def send(_):
nonlocal sends
sends += 1
if sends == 2:
raise ConnectionError("Viewer disconnected")
with pytest.raises(ConnectionError):
await asyncio.wait_for(
_subscribe_with_progress(SimpleNamespace(subscribe=subscribe), object(), send), 4
)
assert cancelled.is_set()
async def test_stopped_browser_turn_cannot_retry_but_new_user_turn_can(tmp_path):
from dodaios.society.browser.bridge import execute_live
from dodaios.society.browser.live import LiveSessions
live = LiveSessions(tmp_path)
live.stop_turn("agent", "denied-turn")
jobs = SimpleNamespace(live=live)
caller = SimpleNamespace(agent_id="agent")
denied = await execute_live(None, caller, jobs, {}, SimpleNamespace(trace_id="denied-turn"))
assert not denied.success and "new user request" in denied.error
fresh = await execute_live(None, caller, jobs, {}, SimpleNamespace(trace_id="new-turn"))
assert "not ready" in fresh.error # A fresh turn reaches normal readiness checks.
@pytest.mark.parametrize("chat_id", ["", "jarvis-root-test"])
async def test_stop_button_also_stops_the_owning_chat(monkeypatch, chat_id):
import asyncio
from dodaios.ui.web import society_browser_routes as routes
seen = []
lock = asyncio.Lock()
await lock.acquire()
session = SimpleNamespace(closed=False, run_lock=lock, active_chat=chat_id)
async def cancel_browser(value, *, end_turn=True):
assert value is session
seen.append(("browser", end_turn))
async def cancel_chat(value):
seen.append(value)
async def resolve(_):
return SimpleNamespace(agent_id="test")
async def runtime(_):
return SimpleNamespace(
roster=SimpleNamespace(resolve=resolve),
browser=SimpleNamespace(
live=SimpleNamespace(sessions={"test": session}, cancel=cancel_browser)
),
)
request = SimpleNamespace(
headers={"x-jarvis-stop-chat": "1"},
app=SimpleNamespace(state=SimpleNamespace(agent_chat=SimpleNamespace(cancel=cancel_chat))),
)
monkeypatch.setattr(routes, "_runtime", runtime)
assert await routes.cancel_agent_browser("test", request) == {"cancelled": True}
assert seen == [("browser", True), chat_id or "society:test"]
async def test_agent_cancel_releases_the_browser_without_stopping_the_chat(monkeypatch):
import asyncio
from dodaios.ui.web import society_browser_routes as routes
seen = []
lock = asyncio.Lock()
await lock.acquire()
session = SimpleNamespace(closed=False, run_lock=lock, active_chat="society:test-bot")
async def cancel_browser(value, *, end_turn=True):
seen.append(end_turn)
async def cancel_chat(value):
seen.append(value)
async def resolve(_):
return SimpleNamespace(agent_id="test-bot")
async def runtime(_):
return SimpleNamespace(
roster=SimpleNamespace(resolve=resolve),
browser=SimpleNamespace(
live=SimpleNamespace(sessions={"test-bot": session}, cancel=cancel_browser)
),
)
request = SimpleNamespace(
headers={"origin": "http://127.0.0.1:47821"},
app=SimpleNamespace(state=SimpleNamespace(agent_chat=SimpleNamespace(cancel=cancel_chat))),
)
monkeypatch.setattr(routes, "_runtime", runtime)
assert await routes.cancel_agent_browser("test-bot", request) == {"cancelled": True}
assert seen == [False]
async def test_open_probe_reports_a_running_browser_without_launching_one(monkeypatch):
import asyncio
from dodaios.ui.web import society_browser_routes as routes
ensured = []
busy = asyncio.Lock()
await busy.acquire()
sessions = {
"busy": SimpleNamespace(closed=False, run_lock=busy),
"done": SimpleNamespace(closed=True, run_lock=asyncio.Lock()),
}
async def resolve(agent_id):
return SimpleNamespace(agent_id=agent_id)
async def ensure(agent, **_):
ensured.append(agent.agent_id)
async def runtime(_):
return SimpleNamespace(
roster=SimpleNamespace(resolve=resolve),
browser=SimpleNamespace(
live=SimpleNamespace(sessions=sessions, ensure=ensure),
status_for=lambda agent: {"mode": "chrome", "profile_name": "Work"},
),
)
monkeypatch.setattr(routes, "_runtime", runtime)
request = SimpleNamespace()
metadata = {"mode": "chrome", "profile_name": "Work"}
assert await routes.agent_browser_open("busy", request) == {
**metadata,
"open": True,
"running": True,
}
assert await routes.agent_browser_open("done", request) == {
**metadata,
"open": False,
"running": False,
}
assert await routes.agent_browser_open("idle", request) == {
**metadata,
"open": False,
"running": False,
}
assert ensured == []
async def test_desktop_fetch_stop_still_ends_the_chat(monkeypatch):
import asyncio
from dodaios.ui.web import society_browser_routes as routes
seen = []
lock = asyncio.Lock()
await lock.acquire()
session = SimpleNamespace(closed=False, run_lock=lock, active_chat="society:test-bot")
async def cancel_browser(value, *, end_turn=True):
seen.append(end_turn)
async def cancel_chat(value):
seen.append(value)
async def resolve(_):
return SimpleNamespace(agent_id="test-bot")
async def runtime(_):
return SimpleNamespace(
roster=SimpleNamespace(resolve=resolve),
browser=SimpleNamespace(
live=SimpleNamespace(sessions={"test-bot": session}, cancel=cancel_browser)
),
)
request = SimpleNamespace(
headers={"origin": "http://127.0.0.1:47821", "sec-fetch-site": "same-origin"},
app=SimpleNamespace(state=SimpleNamespace(agent_chat=SimpleNamespace(cancel=cancel_chat))),
)
monkeypatch.setattr(routes, "_runtime", runtime)
assert await routes.cancel_agent_browser("test-bot", request) == {"cancelled": True}
assert seen == [True, "society:test-bot"]
async def test_same_chat_replaces_an_abandoned_browser_run():
import asyncio
from dodaios.society.browser.live import claim_browser
lock = asyncio.Lock()
started = asyncio.Event()
released = asyncio.Event()
async def owner():
async with lock:
started.set()
await released.wait()
task = asyncio.create_task(owner())
await started.wait()
async def command(op, **_kwargs):
assert op == "cancel"
released.set()
return {}
session = SimpleNamespace(
control_owner=None,
run_lock=lock,
active_chat="society:test-bot",
attention={},
closed=False,
command=command,
)
await claim_browser(session, "society:test-bot")
assert not lock.locked()
await task
async def test_another_chat_and_manual_control_stay_busy():
import asyncio
from dodaios.society.browser.live import claim_browser
lock = asyncio.Lock()
await lock.acquire()
session = SimpleNamespace(
control_owner=None,
run_lock=lock,
active_chat="society:other",
attention={},
closed=False,
)
with pytest.raises(RuntimeError, match="busy"):
await claim_browser(session, "society:test-bot")
session.control_owner = "viewer"
session.active_chat = ""
lock.release()
with pytest.raises(RuntimeError, match="busy"):
await claim_browser(session, "society:test-bot")
async def test_pending_approval_is_not_replaced():
import asyncio
from dodaios.society.browser.live import claim_browser
lock = asyncio.Lock()
await lock.acquire()
called = []
async def command(op, **_kwargs):
called.append(op)
return {}
session = SimpleNamespace(
control_owner=None,
run_lock=lock,
active_chat="society:test-bot",
attention={"approval": {"id": "1"}},
closed=False,
command=command,
)
with pytest.raises(RuntimeError, match="paused"):
await claim_browser(session, "society:test-bot")
assert called == []
assert lock.locked()
lock.release()
async def test_bare_cancel_does_not_mark_the_turn_stopped(tmp_path):
from dodaios.society.browser.live import LiveSessions
live = LiveSessions(tmp_path)
called = []
async def command(op, **_kwargs):
called.append(op)
return {}
session = SimpleNamespace(
agent_id="test-bot", active_trace="trace-1", closed=False, command=command
)
await live.cancel(session, end_turn=False)
assert called == ["cancel"]
assert ("test-bot", "trace-1") not in live.stopped_turns
await live.cancel(session, end_turn=True)
assert ("test-bot", "trace-1") in live.stopped_turns
@pytest.mark.parametrize(
"state,active_trace,chat_id,approve,running,stops",
[
("pending", "turn", "root-chat", False, True, True),
("pending", "turn", "society:test", False, True, True),
("pending", "new-turn", "root-chat", False, True, False),
("denied", "turn", "root-chat", False, True, False),
("approved", "turn", "root-chat", False, True, False),
("pending", "turn", "", False, True, False),
("pending", "turn", "root-chat", True, True, False),
("pending", "turn", "root-chat", False, False, False),
],
)
async def test_browser_denial_stops_only_its_planner_before_releasing_reply(
monkeypatch, state, active_trace, chat_id, approve, running, stops
):
import asyncio
from dodaios.ui.web import society_routes as routes
seen = []
lock = asyncio.Lock()
if running:
await lock.acquire()
session = SimpleNamespace(active_trace=active_trace, active_chat=chat_id, run_lock=lock)
item = SimpleNamespace(
agent_id="test",
trace_id="turn",
capability="core:browser",
state=state,
action={"resume_in_place": True},
to_dict=lambda: {},
)
async def get(_):
return item
async def resolve(*_args, **_kwargs):
seen.append("resolve")
return item
async def runtime(_):
return SimpleNamespace(
approvals=SimpleNamespace(get=get, resolve=resolve),
browser=SimpleNamespace(live=SimpleNamespace(sessions={"test": session})),
)
request = SimpleNamespace(
app=SimpleNamespace(
state=SimpleNamespace(
agent_chat=SimpleNamespace(signal_cancel=lambda sid: seen.append(sid)),
)
)
)
monkeypatch.setattr(routes, "_runtime", runtime)
await routes.resolve_approval("approval", routes.ResolveApprovalBody(approve=approve), request)
assert seen == ([chat_id, "resolve"] if stops else ["resolve"])
async def test_jarvis_chat_uses_the_lead_browser_with_its_selected_model(tmp_path, monkeypatch):
from dodaios.agent_chat.surface_kits import kit_for
from dodaios.agent_chat.tool_catalog import build_catalog, resolve_choices
from dodaios.core.protocols import ToolResult
from dodaios.society.runtime import SocietyRuntime
runtime = SocietyRuntime(tmp_path, seed_starter_team=False)
await runtime.ensure_started()
seen = []
async def execute(rt, caller, jobs, args, ctx, *, read_only=False):
seen.append((caller.agent_id, caller.provider, caller.model))
return ToolResult(True, {"ok": True}, None)
monkeypatch.setattr("dodaios.society.browser.bridge.execute_live", execute)
try:
original = await runtime.roster.get(runtime.lead_id)
session = SimpleNamespace(
provider="openrouter",
model="selected-model",
cwd=str(tmp_path / "chat"),
permission_mode="ask",
)
tools = kit_for("jarvis").session_tools(None, None, session)
assert "Read" in tools
choice = resolve_choices(["tool:society_browser"], build_catalog(tools))[0]
assert choice.tool_names == ("society_browser",)
result = await tools["society_browser"].execute(
{"task": "Read the page"}, SimpleNamespace()
)
assert result.success
assert seen == [(runtime.lead_id, "openrouter", "selected-model")]
current = await runtime.roster.get(runtime.lead_id)
assert (current.provider, current.model) == (original.provider, original.model)
finally:
await runtime.close()
async def test_upload_rejects_files_outside_the_agent_workspace(tmp_path, monkeypatch):
from dodaios.society.browser.bridge import execute_live
from dodaios.society.browser.live import LiveSessions
monkeypatch.setattr("dodaios.core.config.get_jarvis_agent_secret", lambda _: None)
live = LiveSessions(tmp_path)
live.executor = object()
live.model_resolver = lambda _: SimpleNamespace(complete=lambda *_: None)
outside = tmp_path / "outside.txt"
outside.write_text("private fixture", encoding="utf-8")
result = await execute_live(
SimpleNamespace(data_dir=tmp_path),
SimpleNamespace(agent_id="test", provider="openai"),
SimpleNamespace(live=live),
{"task": "Upload", "files": [str(outside)]},
SimpleNamespace(trace_id="test"),
)
assert not result.success and "inside this agent's workspace" in result.error
assert not live.sessions
@pytest.mark.parametrize(
"value",
[
{"op": "evaluate", "args": {}},
{"op": "click", "args": {"x": float("nan"), "y": 1}},
{"op": "click", "args": {"x": 1}},
{"op": "text", "args": {"text": "x" * 8193}},
],
)
def test_invalid_remote_controls_are_rejected(value):
with pytest.raises(ValueError):
validate_control(value)
def test_browser_multimodal_messages_preserve_images():
messages = brain_messages(
[
{
"role": "user",
"content": [
{"type": "text", "text": "Look at this"},
{"type": "image_url", "image_url": {"url": "data:image/png;base64,YQ=="}},
],
}
]
)
assert messages[0].content == "Look at this"
assert messages[0].images[0].data_b64 == "YQ=="
async def test_slow_viewer_keeps_approval_and_only_latest_pixels():
from dodaios.society.browser.live import LiveUpdates
buffer = LiveUpdates()
buffer.put_nowait({"kind": "approval", "id": "one"})
for sequence in range(100):
buffer.put_nowait({"kind": "frame", "sequence": sequence})
assert (await buffer.get())["id"] == "one"
assert (await buffer.get())["sequence"] == 99
async def test_slow_viewer_does_not_clear_a_newer_approval():
from dodaios.society.browser.live import LiveUpdates
buffer = LiveUpdates()
buffer.put_nowait({"kind": "approval", "id": "old"})
buffer.put_nowait({"kind": "approval_cleared", "id": "old"})
buffer.put_nowait({"kind": "approval", "id": "new"})
assert await buffer.get() == {"kind": "approval_cleared", "id": "old"}
assert await buffer.get() == {"kind": "approval", "id": "new"}
def test_browser_children_do_not_inherit_provider_credentials(monkeypatch, tmp_path):
from dodaios.society.browser.install import worker_env
monkeypatch.setenv("OPENAI_API_KEY", "test-placeholder")
monkeypatch.setenv("EXAMPLE_ACCESS_TOKEN", "test-placeholder")
monkeypatch.setenv("AWS_ACCESS_KEY_ID", "test-placeholder")
monkeypatch.setenv("DATABASE_PASSWORD", "test-placeholder")
monkeypatch.setenv("PIP_INDEX_URL", "https://example.invalid/simple")
env = worker_env(tmp_path)
assert "OPENAI_API_KEY" not in env
assert "EXAMPLE_ACCESS_TOKEN" not in env
assert "AWS_ACCESS_KEY_ID" not in env
assert "DATABASE_PASSWORD" not in env
assert env["PYTHON_DOTENV_DISABLED"] == "1"
assert "PIP_INDEX_URL" not in env
assert env["ANONYMIZED_TELEMETRY"] == "false"
def test_managed_python_uses_windows_emulation_only_where_needed():
from dodaios.society.browser.install import managed_python_request
assert managed_python_request("win32", "ARM64") == "cpython-3.12-windows-x86_64-none"
assert managed_python_request("win32", "AMD64") == "3.12"
assert managed_python_request("linux", "aarch64") == "3.12"
assert managed_python_request("darwin", "arm64") == "3.12"
@pytest.mark.parametrize("burst", [False, True])
async def test_viewer_disconnect_cancels_pending_takeover(monkeypatch, burst):
import asyncio
from starlette.websockets import WebSocketDisconnect
from dodaios.ui.web import society_browser_routes as routes
started = asyncio.Event()
cancelled = asyncio.Event()
released = asyncio.Event()
completed = asyncio.Event()
seen = []
class Live:
async def subscribe(self, agent):
return SimpleNamespace(state={}, generation="test-generation", control_owner=None), asyncio.Queue()
async def control(self, *args):
started.set()
if burst:
await asyncio.sleep(0.01)
seen.append(args[-1]["text"])
if len(seen) == 20:
completed.set()
return {}
try:
await asyncio.Event().wait()
finally:
cancelled.set()
async def unsubscribe(self, *args):
released.set()
class Socket:
scope = {}
reads = 0
async def accept(self):
pass # Test socket has no transport to accept.
async def close(self, **kwargs):
pass # Test socket has no transport to close.
async def receive_json(self):
self.reads += 1
if burst:
if self.reads <= 20:
return {"op": "text", "args": {"text": str(self.reads)}}
await completed.wait()
raise WebSocketDisconnect()
if self.reads == 1:
return {"op": "takeover", "args": {"enabled": True}}
await started.wait()
raise WebSocketDisconnect()
async def send_json(self, value):
pass # No response is expected before the disconnect.
async def resolve(_):
return SimpleNamespace(agent_id="test")
async def runtime(_):
return SimpleNamespace(
roster=SimpleNamespace(resolve=resolve), browser=SimpleNamespace(live=Live())
)
monkeypatch.setattr(routes, "_runtime", runtime)
monkeypatch.setattr(routes, "credentials_valid", lambda _: True)
await asyncio.wait_for(routes.agent_browser_live(Socket(), "test"), 2)
if burst:
assert seen == [str(n) for n in range(1, 21)]
else:
assert cancelled.is_set()
assert released.is_set()
async def test_busy_shared_profile_names_its_holder_to_the_viewer(monkeypatch):
from dodaios.society.browser.live import BrowserProfileBusy
from dodaios.ui.web import society_browser_routes as routes
sent: list[dict] = []
class Live:
async def subscribe(self, agent):
raise BrowserProfileBusy("juno", "Juno", running=True)
class Socket:
scope = {}
async def accept(self):
pass # Test socket has no transport to accept.
async def close(self, **kwargs):
pass # Test socket has no transport to close.
async def send_json(self, value):
sent.append(value)
async def resolve(_):
return SimpleNamespace(agent_id="wren")
async def runtime(_):
return SimpleNamespace(
roster=SimpleNamespace(resolve=resolve), browser=SimpleNamespace(live=Live())
)
monkeypatch.setattr(routes, "_runtime", runtime)
monkeypatch.setattr(routes, "credentials_valid", lambda _: True)
await routes.agent_browser_live(Socket(), "wren")
error = next(m for m in sent if m["kind"] == "error")
assert error["code"] == "profile_busy"
assert (error["holder_id"], error["holder_name"], error["running"]) == ("juno", "Juno", True)
assert "Juno is running a task" in error["error"]
async def test_hover_motion_coalesces_and_never_delays_or_drops_clicks(monkeypatch):
import asyncio
from starlette.websockets import WebSocketDisconnect
from dodaios.ui.web import society_browser_routes as routes
clicked = asyncio.Event()
# Every message is read before the first motion's round trip ends, so the
# result does not depend on how fast the runner reads 401 messages.
all_read = asyncio.Event()
seen: list[tuple[str, int | None]] = []
sent: list[dict] = []
class Live:
async def subscribe(self, agent):
return SimpleNamespace(state={}, generation="g", control_owner=None), asyncio.Queue()
async def control(self, _session, _owner, op, args):
seen.append(("hover" if args.get("move_only") else op, args.get("x")))
await all_read.wait()
await asyncio.sleep(0.02) # A slow worker round trip.
if op == "click" and not args.get("move_only"):
clicked.set()
return {}
async def unsubscribe(self, *args):
pass # Nothing to release in this fake.
class Socket:
scope = {}
reads = 0
async def accept(self):
pass # Test socket has no transport to accept.
async def close(self, **kwargs):
pass # Test socket has no transport to close.
async def receive_json(self):
self.reads += 1
# 400 motions overflowed the old 256-entry queue and closed the view.
if self.reads <= 400:
return {"op": "click", "args": {"x": self.reads, "y": 1, "move_only": True}}
if self.reads == 401:
all_read.set()
return {"op": "click", "args": {"x": 9999, "y": 1}}
await clicked.wait()
raise WebSocketDisconnect()
async def send_json(self, value):
sent.append(value)
async def resolve(_):
return SimpleNamespace(agent_id="test")
async def runtime(_):
return SimpleNamespace(
roster=SimpleNamespace(resolve=resolve), browser=SimpleNamespace(live=Live())
)
monkeypatch.setattr(routes, "_runtime", runtime)
monkeypatch.setattr(routes, "credentials_valid", lambda _: True)
await asyncio.wait_for(routes.agent_browser_live(Socket(), "test"), 2)
assert ("click", 9999) in seen
# The click waits for at most the one motion already in flight.
assert seen.index(("click", 9999)) <= 2
assert sum(1 for kind, _ in seen if kind == "hover") <= 2
assert [m for m in sent if m.get("kind") == "control"] == [
{"kind": "control", "op": "click", "ok": True}
]
@pytest.mark.parametrize(
"detail",
[
"This model cannot see images. Pick a multimodal model.",
"This model does not support image input.",
],
)
async def test_text_only_model_retries_with_dom_and_keeps_images_disabled(
tmp_path, monkeypatch, detail
):
from dodaios.core.protocols import BrainDelta
from dodaios.society.browser.bridge import execute_live
from dodaios.society.runtime import SocietyRuntime
seen = []
class TextBrain:
supports_vision = True # Adapter capability; the selected model is text-only.
context_window = 32768
async def complete(self, request):
seen.append(request)
if any(m.images for m in request.messages):
raise RuntimeError(detail)
yield BrainDelta(content='{"action": [{"done": {"success": true}}]}')
monkeypatch.setattr("dodaios.core.config.get_jarvis_agent_secret", lambda _: None)
rt = SocietyRuntime(tmp_path, seed_starter_team=False)
await rt.ensure_started()
rt.browser.live.model_resolver = lambda _: TextBrain()
rt.browser.live.executor = object()
async def run(agent, *, llm, **kwargs):
payload = {
"messages": [
{
"role": "user",
"content": [
{"type": "text", "text": "DOM: [1] button Save"},
{"type": "image_url", "image_url": {"url": "data:image/png;base64,YQ=="}},
],
}
]
}
assert (await llm(payload))["ok"]
assert (await llm(payload))["ok"]
return {"ok": True, "artifacts": []}
rt.browser.live.run = run
try:
agent, _ = await rt.roster.create(name="Text model", provider="ollama")
result = await execute_live(
rt, agent, rt.browser, {"task": "Read"}, SimpleNamespace(trace_id="dom", config={})
)
assert result.success
assert len(seen) == 3
assert seen[0].messages[0].images
assert all(not m.images for req in seen[1:] for m in req.messages)
assert all("DOM: [1] button Save" in str(req.messages[0].content) for req in seen)
finally:
await rt.close()
async def test_completed_chat_cancels_only_its_pending_browser(tmp_path, monkeypatch):
import asyncio
from dodaios.society.browser.tool import stop_chat_browser
from dodaios.society.runtime import SocietyRuntime
rt = SocietyRuntime(tmp_path, seed_starter_team=False)
await rt.ensure_started()
cancelled = []
own = SimpleNamespace(active_chat="ended", run_lock=asyncio.Lock())
other = SimpleNamespace(active_chat="other", run_lock=asyncio.Lock())
idle = SimpleNamespace(active_chat="ended", run_lock=asyncio.Lock())
await own.run_lock.acquire()
await other.run_lock.acquire()
async def cancel(session):
cancelled.append(session)
session.run_lock.release()
rt.browser.live.sessions = {"own": own, "other": other, "idle": idle}
monkeypatch.setattr(rt.browser.live, "cancel", cancel)
try:
await stop_chat_browser("ended")
assert cancelled == [own]
assert not own.run_lock.locked()
assert other.run_lock.locked()
finally:
rt.browser.live.sessions.clear()
other.run_lock.release()
await rt.close()
async def test_chat_only_model_has_actionable_browser_failure_without_paid_fallback(
tmp_path, monkeypatch
):
from dodaios.society.browser.bridge import execute_live
from dodaios.society.browser.live import LiveSessions
live = LiveSessions(tmp_path)
live.executor = object()
calls = []
def unavailable(caller):
calls.append(caller.provider)
raise KeyError("No inference implementation")
live.model_resolver = unavailable
monkeypatch.setattr("dodaios.core.config.get_jarvis_agent_secret", lambda _: None)
result = await execute_live(
SimpleNamespace(data_dir=tmp_path),
SimpleNamespace(agent_id="test", provider="chat-only"),
SimpleNamespace(live=live),
{"task": "Read"},
SimpleNamespace(trace_id="one", config={}),
)
assert not result.success
assert "Model menu" in result.error
assert calls == ["chat-only"]
assert live.sessions == {}