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.

6.7 KB
Raw Blame
"""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")