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
"""Session policy: the Agents-tier pair, one session per install, an honest refusal."""
from __future__ import annotations
import pytest
from dodaios.agent_chat.service import AgentChatService
from dodaios.agent_chat.store import AgentChatStore
from dodaios.core.config import BrainProviderConfig, BrainTierConfig, JarvisConfig
from dodaios.local_models import assistant_session as policy
def _cfg(provider: str = "openai", model: str = "gpt-x", **fallback: str) -> JarvisConfig:
cfg = JarvisConfig()
cfg.brain.worker = BrainTierConfig(provider=provider, model=model, **fallback)
return cfg
def _svc() -> AgentChatService:
return AgentChatService(AgentChatStore(":memory:"))
def test_tier_is_the_worker_pair_and_ready_only_with_a_credential() -> None:
ready = policy.agents_tier(_cfg(), usable=lambda p: p == "openai")
assert (ready.provider, ready.model, ready.ready, ready.reason) == ("openai", "gpt-x", True, "")
blocked = policy.agents_tier(_cfg(), usable=lambda _p: False)
assert blocked.ready is False and blocked.reason == policy.NOT_READY
def test_unknown_primary_falls_back_to_the_fallback_pair() -> None:
cfg = _cfg("some-cli-only-thing", "m", fallback_provider="gemini", fallback_model="g-2")
tier = policy.agents_tier(cfg, usable=lambda _p: True)
assert (tier.provider, tier.model) == ("gemini", "g-2")
def test_a_cli_only_primary_yields_to_the_tool_capable_fallback() -> None:
"""Antigravity drives a CLI on a flat prompt and drops every tool; the
assistant needs its lm_* tools, so the chain moves on to a fallback that
can call them — and says why when none can."""
cfg = _cfg("antigravity", "gemini-3.5-flash", fallback_provider="gemini", fallback_model="g-2")
tier = policy.agents_tier(
cfg, usable=lambda _p: True, tool_capable=lambda p: p != "antigravity"
)
assert (tier.provider, tier.model, tier.ready) == ("gemini", "g-2", True)
stuck = policy.agents_tier(cfg, usable=lambda _p: True, tool_capable=lambda _p: False)
assert stuck.ready is False and stuck.reason == policy.NO_TOOLS
def test_the_real_antigravity_plugin_reports_no_tools() -> None:
assert policy._tool_capable("antigravity") is False
assert policy._tool_capable("gemini") is True
def test_no_worker_tier_is_not_ready() -> None:
cfg = JarvisConfig()
cfg.brain.worker = None
tier = policy.agents_tier(cfg, usable=lambda _p: True)
assert tier.ready is False and tier.reason == policy.NOT_READY
def test_ensure_session_creates_once_and_recreates_when_the_tier_moves() -> None:
svc = _svc()
cfg = _cfg()
first = policy.ensure_session(svc, cfg, usable=lambda _p: True)
again = policy.ensure_session(svc, cfg, usable=lambda _p: True)
assert first.session_id == again.session_id
assert first.surface == "local-models" and first.provider == "openai"
assert first.permission_mode == "bypass"
moved = policy.ensure_session(svc, _cfg(model="gpt-y"), usable=lambda _p: True)
assert moved.session_id != first.session_id and moved.model == "gpt-y"
assert len(svc.store.list_sessions(surface="local-models")) == 2
def test_ensure_session_refuses_without_the_tier() -> None:
svc = _svc()
with pytest.raises(PermissionError, match="Pick a Tool Model with an API key first"):
policy.ensure_session(svc, _cfg(), usable=lambda _p: False)
assert svc.store.list_sessions(surface="local-models") == []
def test_session_state_shape() -> None:
svc = _svc()
cfg = _cfg()
assert policy.session_state(svc, cfg, usable=lambda _p: True) == {
"session_id": None,
"surface": "local-models",
"provider": "openai",
"model": "gpt-x",
"ready": True,
"reason": "",
}
session = policy.ensure_session(svc, cfg, usable=lambda _p: True)
state = policy.session_state(svc, cfg, usable=lambda _p: False)
assert state["session_id"] == session.session_id
assert state["ready"] is False and state["reason"] == policy.NOT_READY
def test_a_pair_the_live_probe_refuses_yields_to_the_next_and_names_the_reason() -> None:
cfg = _cfg("gemini", "g-pro", fallback_provider="openai", fallback_model="o-1")
live = {
("gemini", "g-pro"): (False, "gemini (g-pro): no credits — quota 0"),
("openai", "o-1"): (True, ""),
}
tier = policy.agents_tier(cfg, usable=lambda _p: True, tool_capable=lambda _p: True, live=live)
assert (tier.provider, tier.model, tier.ready) == ("openai", "o-1", True)
live[("openai", "o-1")] = (False, "openai (o-1): bad key")
stuck = policy.agents_tier(cfg, usable=lambda _p: True, tool_capable=lambda _p: True, live=live)
assert stuck.ready is False and stuck.reason == "openai (o-1): bad key"
@pytest.mark.asyncio
async def test_probe_live_classifies_with_the_provider_test_and_caches() -> None:
from dodaios.brain.provider_test import ProviderTestResult
policy._reset_for_tests()
calls: list[tuple[str, str | None]] = []
async def _tester(spec, cfg, *, model=None, timeout_s=20.0):
calls.append((spec.id, model))
status = "no_credits" if spec.id == "gemini" else "ok"
return ProviderTestResult(provider=spec.id, status=status, detail="quota 0")
cfg = _cfg("gemini", "g-pro", fallback_provider="openai", fallback_model="o-1")
pairs = policy.chain_candidates(cfg, usable=lambda _p: True, tool_capable=lambda _p: True)
out = await policy.probe_live(cfg, pairs, tester=_tester)
assert out[("gemini", "g-pro")] == (
False,
"gemini (g-pro): the account has no credit or quota left for this model.",
)
assert out[("openai", "o-1")] == (True, "")
again = await policy.probe_live(cfg, pairs, tester=_tester)
assert again == out and len(calls) == 2 # cached, no second real call
def test_the_tool_model_comes_first_and_the_agents_chain_is_the_fallback() -> None:
"""The user answers "which model does my own work" once, in the Tool
Model tab; the assistant honours that pick and bills through its key."""
cfg = _cfg("openai", "gpt-x")
cfg.brain.tool_model = BrainTierConfig(provider="vertex")
cfg.brain.providers["vertex"] = BrainProviderConfig(tool_model="gemini-3.6-flash")
assert policy._chain(cfg)[0] == ("vertex", "gemini-3.6-flash")
tier = policy.agents_tier(cfg, usable=lambda _p: True, tool_capable=lambda _p: True)
assert (tier.provider, tier.model) == ("vertex", "gemini-3.6-flash")
# An unusable Tool Model falls back to the Agents chain, honestly.
tier = policy.agents_tier(cfg, usable=lambda p: p != "vertex", tool_capable=lambda _p: True)
assert (tier.provider, tier.model) == ("openai", "gpt-x")
cfg.brain.tool_model = BrainTierConfig(provider="auto")
assert policy._chain(cfg)[0] == ("openai", "gpt-x")