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
"""Permission ladders, the agy wire shape, CLI model catalogs, API effort."""
from __future__ import annotations
import json
from pathlib import Path
from types import SimpleNamespace
import pytest
from dodaios.agent_chat import permissions, runner_cli
from dodaios.agent_chat.catalog import provider_row
from dodaios.agent_chat.runner_cli import (
_AgyState,
agy_model_args,
agy_model_catalog,
plan_agy,
plan_claude,
plan_codex,
translate_agy_line,
)
from dodaios.plugins.brain._anthropic_base import _is_reasoning_model, reasoning_kwargs
# ------------------------------------------------------------ permissions
async def test_agy_cold_chat_resolves_catalog_before_building_command(tmp_path, monkeypatch):
seen = []
def catalog(**kwargs):
seen.append("catalog")
return []
def planner(**kwargs):
assert seen == ["catalog"]
assert kwargs["effort"] == "high"
raise runner_cli.CliUnavailable("stop before process launch")
monkeypatch.setattr(runner_cli, "read_agy_models", catalog)
monkeypatch.setitem(runner_cli._PLANNERS, "agy-cli", planner)
handle = SimpleNamespace(
session=SimpleNamespace(
session_id="society:nala",
cwd=str(tmp_path),
provider="antigravity",
model="new-model",
effort="high",
permission_mode="plan",
)
)
result = await runner_cli._run_cli_once(handle, "Read a page", "agy-cli", None)
assert result.status == "error"
assert result.error == "stop before process launch"
def test_agy_refreshes_a_cached_fallback_missing_the_scheduled_model(monkeypatch):
import subprocess
import time
monkeypatch.setattr(
runner_cli,
"_AGY_CATALOG",
{
"at": time.monotonic(),
"rows": [{"id": "old-model", "efforts": []}],
},
)
monkeypatch.setattr(runner_cli, "agy_argv_prefix", lambda: ["agy"])
calls = []
def models(*args, **kwargs):
calls.append(args)
return SimpleNamespace(
stdout=json.dumps(
{
"command": {
"data": {
"models": [
{"id": "current-model-low"},
{"id": "current-model-high"},
]
}
}
}
).encode()
)
monkeypatch.setattr(subprocess, "run", models)
rows = runner_cli.read_agy_models(required_model="current-model")
assert agy_model_args("current-model", "high", rows) == [
"--model",
"current-model",
"--effort",
"high",
]
runner_cli.read_agy_models(required_model="current-model")
assert len(calls) == 1
def test_every_runner_has_a_ladder_with_its_default_on_it():
for runner in ("claude-cli", "codex-cli", "agy-cli", "grok-cli", "api", "jarvis"):
ids = permissions.permission_ids(runner)
assert ids, runner
assert permissions.default_permission(runner) in ids, runner
# Plan is the Build | Plan switch; every ladder offers it.
assert "plan" in ids, runner
@pytest.mark.parametrize(
("runner", "picked", "expected"),
[
("claude-cli", "acceptEdits", "acceptEdits"),
("claude-cli", "auto", "auto"), # Claude Code's own classifier mode
("claude-cli", "ask", "default"), # legacy draft value
("claude-cli", "full-access", "bypassPermissions"),
("codex-cli", "acceptEdits", "auto"), # Codex's "auto" = workspace-write
("codex-cli", "bypassPermissions", "full-access"),
("codex-cli", "plan", "plan"),
("agy-cli", "default", "accept-edits"), # ask is never folded onto plan
("agy-cli", "bypassPermissions", "skip-permissions"),
("api", "acceptEdits", "accept-edits"),
("api", "", "auto"),
("api", "read-only", "plan"),
# The Jarvis ladder's words, folded onto every seat's own spelling.
("claude-cli", "bypass", "bypassPermissions"),
("claude-cli", "accept-edits", "acceptEdits"),
("claude-cli", "ask", "default"),
("codex-cli", "ask", "approve-for-me"),
("codex-cli", "accept-edits", "auto"),
("codex-cli", "bypass", "full-access"),
("agy-cli", "bypass", "skip-permissions"),
("agy-cli", "ask", "accept-edits"),
("grok-cli", "accept-edits", "acceptEdits"),
("grok-cli", "bypass", "bypassPermissions"),
("jarvis", "", "bypass"),
("jarvis", "acceptEdits", "accept-edits"),
("jarvis", "bypassPermissions", "bypass"),
("jarvis", "plan", "plan"),
],
)
def test_normalize_permission_folds_across_runners(runner, picked, expected):
assert permissions.normalize_permission(runner, picked) == expected
def test_the_jarvis_ladder_is_the_three_stances_and_plan():
assert permissions.permission_ids("jarvis") == ("ask", "accept-edits", "plan", "bypass")
assert permissions.ladder_key("jarvis", "claude-cli") == "jarvis"
assert permissions.ladder_key("jarvis", "brain") == "jarvis"
assert permissions.ladder_key("agent", "claude-cli") == "claude-cli"
stances = [permissions.stance_of(m) for m in ("plan", "ask", "accept-edits", "bypass")]
assert stances == [0, 1, 2, 3]
assert permissions.stance_of("nonsense") == 1
# ------------------------------------------------------------ planners
def test_claude_planner_passes_the_cli_mode_through(monkeypatch, tmp_path: Path):
monkeypatch.setattr(runner_cli, "claude_argv_prefix", lambda: ["claude"])
plan = plan_claude(
prompt="hi", cwd=tmp_path, model="opus", effort="xhigh", permission_mode="plan", resume=None
)
argv = plan.argv
assert argv[argv.index("--permission-mode") + 1] == "plan"
assert argv[argv.index("--effort") + 1] == "xhigh"
assert argv[argv.index("--model") + 1] == "opus"
assert plan.shape == "claude" and plan.keep_stdin
# The control protocol: NDJSON user message in, prompts answered on stdin.
assert argv[argv.index("--input-format") + 1] == "stream-json"
assert argv[argv.index("--permission-prompt-tool") + 1] == "stdio"
assert json.loads(plan.stdin_text or "") == {
"type": "user",
"message": {"role": "user", "content": "hi"},
}
def test_claude_planner_asks_for_thinking_summaries(monkeypatch, tmp_path: Path):
"""Print mode leaves thinking blocks empty; summaries are the thread's reasoning."""
from dodaios import claude_auth
monkeypatch.setattr(runner_cli, "claude_argv_prefix", lambda: ["claude"])
monkeypatch.setattr(runner_cli, "_registry_env", lambda _name, env: env)
monkeypatch.setitem(claude_auth._THINKING_DISPLAY_CACHE, ("claude",), True)
args = dict(
prompt="hi", cwd=tmp_path, model="", effort="", permission_mode="default", resume=None
)
argv = plan_claude(**args).argv
assert argv[argv.index("--thinking-display") + 1] == "summarized"
# GLM rides Claude Code against another endpoint and is never asked.
assert "--thinking-display" not in runner_cli.plan_glm(**args).argv
# An older CLI (probe False) gets no flag it would reject.
monkeypatch.setitem(claude_auth._THINKING_DISPLAY_CACHE, ("claude",), False)
assert "--thinking-display" not in plan_claude(**args).argv
def test_claude_planner_opens_the_control_protocol(monkeypatch, tmp_path: Path):
"""The handshake, without which no permission mode can ever ask.
``--permission-prompt-tool stdio`` is a flag Claude Code accepts and then
ignores until a client announces itself over the control protocol. Without
this frame every tool call ran straight through, so "Ask before acting"
behaved exactly like "Auto-accept edits" (maintainer report 2026-08-24).
"""
monkeypatch.setattr(runner_cli, "claude_argv_prefix", lambda: ["claude"])
plan = plan_claude(
prompt="hi", cwd=tmp_path, model="", effort="", permission_mode="default", resume=None
)
assert plan.control_init is not None
frame = json.loads(plan.control_init)
assert frame["type"] == "control_request"
assert frame["request"]["subtype"] == "initialize"
# One frame per line: the CLI reads its stdin as NDJSON.
assert plan.control_init.endswith("\n")
def test_codex_planner_maps_the_presets(monkeypatch, tmp_path: Path):
monkeypatch.setattr(runner_cli, "codex_argv_prefix", lambda: ["codex"])
monkeypatch.setattr(runner_cli, "read_codex_models", lambda: None)
def argv_for(mode: str, effort: str = "high", model: str = "") -> list[str]:
return plan_codex(
prompt="p", cwd=tmp_path, model=model, effort=effort, permission_mode=mode, resume=None
).argv
assert 'sandbox_mode="read-only"' in argv_for("read-only")
assert 'sandbox_mode="workspace-write"' in argv_for("auto")
assert "--dangerously-bypass-approvals-and-sandbox" in argv_for("full-access")
approve = argv_for("approve-for-me")
assert (
'approvals_reviewer="auto_review"' in approve
and 'sandbox_mode="workspace-write"' in approve
)
plan = plan_codex(
prompt="p", cwd=tmp_path, model="", effort="high", permission_mode="plan", resume=None
)
assert 'sandbox_mode="read-only"' in plan.argv
assert plan.stdin_text is not None and plan.stdin_text.startswith("PLAN MODE")
# Never the flags codex exec rejects with exit 2.
for argv in (argv_for("auto"), argv_for("full-access")):
assert "--full-auto" not in argv and "-a" not in argv
assert "model_reasoning_summary=auto" in argv_for("auto")
# Effort is snapped to the model's own ladder when the catalog knows it.
monkeypatch.setattr(
runner_cli,
"read_codex_models",
lambda: [
{"id": "gpt-5.5", "label": "GPT-5.5", "efforts": ["low", "medium", "high", "xhigh"]}
],
)
assert "model_reasoning_effort=xhigh" in argv_for("auto", effort="ultra", model="gpt-5.5")
def test_codex_resume_uses_the_resume_subcommand(monkeypatch, tmp_path: Path):
monkeypatch.setattr(runner_cli, "codex_argv_prefix", lambda: ["codex"])
monkeypatch.setattr(runner_cli, "read_codex_models", lambda: None)
argv = plan_codex(
prompt="p", cwd=tmp_path, model="", effort="", permission_mode="auto", resume="thread-1"
).argv
assert argv[1:4] == ["exec", "resume", "thread-1"]
assert "--cd" not in argv # exec resume has no --cd
assert argv[-1] == "-"
def test_agy_planner_speaks_agy(monkeypatch, tmp_path: Path):
monkeypatch.setattr(runner_cli, "agy_argv_prefix", lambda: ["agy"])
monkeypatch.setattr(runner_cli, "_agy_catalog_cached", lambda: None)
plan = plan_agy(
prompt="do it",
cwd=tmp_path,
model="gemini-3.1-pro",
effort="medium",
permission_mode="accept-edits",
resume=None,
)
argv = plan.argv
assert plan.shape == "agy"
assert plan.stdin_text == "do it" and "-p" not in argv and "--print" not in argv
assert argv[argv.index("--mode") + 1] == "accept-edits"
# Print-mode agy exits after a soft-denied RunCommand; accept-edits
# therefore also skips confirmations so the turn can finish.
assert "--dangerously-skip-permissions" in argv
assert argv[argv.index("--add-dir") + 1] == str(tmp_path)
# agy's own 5-minute print limit is lifted: a turn may run for days.
assert argv[argv.index("--print-timeout") + 1] == f"{365 * 24 * 3600}s"
# Pro knows only low/high: medium snaps to low, and the pair is sent.
assert argv[argv.index("--model") + 1] == "gemini-3.1-pro"
assert argv[argv.index("--effort") + 1] == "low"
assert plan.env.get("AGY_CLI_HIDE_LOGO") == "1"
skip = plan_agy(
prompt="x",
cwd=tmp_path,
model="",
effort="",
permission_mode="skip-permissions",
resume="c1",
).argv
assert (
"--dangerously-skip-permissions" in skip and skip[skip.index("--conversation") + 1] == "c1"
)
assert "--mode" not in skip
planned = plan_agy(
prompt="x", cwd=tmp_path, model="", effort="", permission_mode="plan", resume=None
).argv
assert planned[planned.index("--mode") + 1] == "plan"
assert "--dangerously-skip-permissions" not in planned
def test_agy_planner_resolves_a_relative_cwd(monkeypatch, tmp_path: Path):
monkeypatch.setattr(runner_cli, "agy_argv_prefix", lambda: ["agy"])
monkeypatch.setattr(runner_cli, "_agy_catalog_cached", lambda: None)
monkeypatch.chdir(tmp_path)
(tmp_path / "data" / "society" / "test" / "workspace").mkdir(parents=True)
plan = plan_agy(
prompt="x",
cwd=Path("data") / "society" / "test" / "workspace",
model="",
effort="",
permission_mode="accept-edits",
resume=None,
)
added = Path(plan.argv[plan.argv.index("--add-dir") + 1])
assert added.is_absolute()
assert added.name == "workspace"
def test_agy_model_args_respects_the_strict_pairing():
assert agy_model_args("claude-sonnet-4-6", "high") == ["--model", "claude-sonnet-4-6"]
assert agy_model_args("gpt-oss-120b", "low") == ["--model", "gpt-oss-120b"]
assert agy_model_args("gemini-3.5-flash", "high") == [
"--model",
"gemini-3.5-flash",
"--effort",
"high",
]
assert agy_model_args("", "medium") == ["--effort", "medium"]
# A suffixed id is passed through untouched (no --effort next to it).
assert agy_model_args("gemini-3.5-flash-low", "high") == ["--model", "gemini-3.5-flash-low"]
# A Gemini release newer than the catalog still gets the level agy
# demands ("requires --effort"): the chosen one, else the default.
assert agy_model_args("gemini-9.9-flash", "") == [
"--model",
"gemini-9.9-flash",
"--effort",
"high",
]
assert agy_model_args("gemini-9.9-flash", "low")[-1] == "low"
def test_agy_new_gemini_base_model_keeps_required_effort_with_stale_catalog():
stale = agy_model_catalog(None)
assert agy_model_args("gemini-3.8-flash", "medium", stale) == [
"--model",
"gemini-3.8-flash",
"--effort",
"medium",
]
assert agy_model_args("gemini-3.8-flash", "", stale)[-2:] == ["--effort", "high"]
assert agy_model_args("gemini-3.8-flash-low", "high", stale) == [
"--model",
"gemini-3.8-flash-low",
]
def test_agy_model_catalog_folds_suffixed_ids():
raw = [
{"id": "gemini-3.7-flash-high", "label": "Gemini 3.7 Flash (High)"},
{"id": "gemini-3.7-flash-low", "label": "Gemini 3.7 Flash (Low)"},
{"id": "gemini-3.7-flash-medium", "label": "Gemini 3.7 Flash (Medium)"},
{"id": "gemini-3.1-pro-high", "label": "Gemini 3.1 Pro (High)"},
{"id": "gemini-3.1-pro-low", "label": "Gemini 3.1 Pro (Low)"},
{"id": "claude-sonnet-4-6", "label": "Claude Sonnet 4.6 (Thinking)"},
{"id": "gpt-oss-120b-medium", "label": "GPT-OSS 120B (Medium)"},
]
rows = agy_model_catalog(raw)
by_id = {r["id"]: r for r in rows}
assert by_id["gemini-3.7-flash"] == {
"id": "gemini-3.7-flash",
"label": "Gemini 3.7 Flash",
"efforts": ["low", "medium", "high"],
}
assert by_id["gemini-3.1-pro"]["efforts"] == ["low", "high"]
assert by_id["claude-sonnet-4-6"]["efforts"] == []
assert by_id["gpt-oss-120b"]["efforts"] == ["medium"]
# No list at all -> the fallback table.
assert agy_model_catalog(None)[0]["id"] == "gemini-3.7-flash"
# ------------------------------------------------------------ agy translation
def _agy_lines() -> list[dict]:
return [
{"event": "init", "conversation_id": "conv-1", "init": {"cwd": "C:\\x", "tools": []}},
{
"event": "step_update",
"step_update": {
"conversation_id": "conv-1",
"step_index": 1,
"state": "ACTIVE",
"step_type": "agent_response",
"text_delta": "Let me ",
},
},
{
"event": "step_update",
"step_update": {
"step_index": 1,
"state": "DONE",
"step_type": "agent_response",
"text_delta": "look.",
},
},
{
"event": "step_update",
"step_update": {
"step_index": 2,
"state": "ACTIVE",
"step_type": "tool",
"tool_name": "run_command",
"tool_info": {"name": "run_command", "parameters": {"CommandLine": "echo HELLO"}},
},
},
{
"event": "step_update",
"step_update": {
"step_index": 2,
"state": "DONE",
"step_type": "tool",
"tool_name": "run_command",
"tool_info": {
"name": "run_command",
"parameters": {"CommandLine": "echo HELLO"},
"output": "HELLO\r\n",
},
"duration_seconds": 1.5,
},
},
{
"event": "step_update",
"step_update": {
"step_index": 3,
"state": "ERROR",
"step_type": "tool",
"tool_name": "run_command",
"tool_info": {
"name": "run_command",
"parameters": {"CommandLine": "rm x"},
"error": {"type": "TOOL_ERROR", "message": "user denied permission"},
},
},
},
{
"event": "result",
"result": {
"conversation_id": "conv-1",
"status": "SUCCESS",
"response": "Done: HELLO",
"duration_seconds": 9.7,
"num_turns": 1,
"usage": {"input_tokens": 10, "output_tokens": 5, "thinking_tokens": 2},
},
},
]
def test_translate_agy_line_builds_the_timeline():
st = _AgyState(turn_id="t1")
events: list[dict] = []
for line in _agy_lines():
events.extend(translate_agy_line(line, st))
kinds = [e["kind"] for e in events]
assert kinds == [
"text_delta",
"text_delta",
"assistant_text",
"tool_call",
"tool_result",
"tool_call",
"tool_result",
]
assert events[2]["payload"]["text"] == "Let me look."
call = events[3]["payload"]
assert call["name"] == "run_command" and call["summary"] == "echo HELLO"
result = events[4]["payload"]
assert result["output"].startswith("HELLO") and result["is_error"] is False
assert result["duration_ms"] == 1500
denied = events[6]["payload"]
assert denied["is_error"] and "denied" in denied["output"]
assert st.vendor_session == "conv-1"
assert st.status == "done" and st.result_text == "Done: HELLO"
assert st.usage == {"input_tokens": 10, "output_tokens": 5, "thinking_tokens": 2}
def test_translate_agy_line_reads_failure_from_result_status():
st = _AgyState(turn_id="t2")
translate_agy_line(
{"event": "result", "result": {"status": "ERROR", "error": "timeout waiting for response"}},
st,
)
assert st.status == "error" and "timeout" in (st.error or "")
st2 = _AgyState(turn_id="t3")
translate_agy_line({"event": "result", "result": {"status": "CANCELED"}}, st2)
assert st2.status == "error"
# ------------------------------------------------------------ codex catalog
def test_read_codex_models_uses_the_executing_cli_not_a_foreign_cache(monkeypatch, tmp_path: Path):
home = tmp_path / "codex-home"
home.mkdir()
(home / "models_cache.json").write_text(
json.dumps({"client_version": "future", "models": [{"slug": "unavailable"}]}),
encoding="utf-8",
)
monkeypatch.setattr(runner_cli, "_account_env", lambda platform: {"CODEX_HOME": str(home)})
monkeypatch.setattr(runner_cli, "codex_argv_prefix", lambda: ["codex-test"])
calls = []
def discover(argv, env, cwd):
calls.append((argv, env))
return [{"id": "future-supported-model", "label": "Future", "efforts": ["high"]}]
monkeypatch.setattr(runner_cli, "discover_codex_models", discover)
rows = runner_cli.read_codex_models()
assert [row["id"] for row in rows] == ["future-supported-model"]
assert calls == [(["codex-test"], {"CODEX_HOME": str(home)})]
assert runner_cli.read_codex_models() == rows
# Society discovery is scoped for exec isolation. The read-only app-server
# must still receive only flags that its own subcommand accepts.
with runner_cli.cli_catalog_scope(ignore_user_config=True):
assert runner_cli.read_codex_models() == rows
assert len(calls) == 1
def test_read_grok_models_reads_the_account_cache(monkeypatch, tmp_path: Path):
home = tmp_path / "grok-home"
home.mkdir()
(home / "models_cache.json").write_text(
json.dumps(
{
"models": {
"grok-4.7": {
"info": {
"id": "grok-4.7",
"name": "Grok 4.7",
"description": "SpaceXAI's latest frontier model",
"hidden": False,
"reasoning_efforts": [
{"value": "xhigh"},
{"value": "high"},
{"value": "low"},
],
}
},
"grok-4.7-build-fast": {
"info": {
"id": "grok-4.7-build-fast",
"name": "Grok 4.7 Fast",
"description": "Fast variant. 2x the price.",
"hidden": False,
"reasoning_efforts": [{"value": "high"}],
}
},
"retired": {"info": {"id": "grok-old", "name": "Old", "hidden": True}},
}
}
),
encoding="utf-8",
)
monkeypatch.setattr(runner_cli, "_account_env", lambda platform: {"GROK_HOME": str(home)})
rows = runner_cli.read_grok_models()
assert rows is not None
assert [row["id"] for row in rows] == ["grok-4.7", "grok-4.7-build-fast"]
assert rows[0]["label"] == "Grok 4.7"
assert rows[0]["efforts"] == ["", "low", "high", "xhigh"]
assert rows[0]["note"] == "SpaceXAI's latest frontier model"
assert rows[1]["note"] == "Fast variant. 2x the price."
monkeypatch.setattr(runner_cli, "_account_env", lambda platform: {"GROK_HOME": str(tmp_path)})
assert runner_cli.read_grok_models() is None
def test_catalog_rows_carry_per_model_efforts_for_cli_runners():
agy = provider_row("antigravity")
assert agy is not None
models = agy.to_dict()["curated_models"]
assert models[0]["id"] == "gemini-3.7-flash" and models[0]["efforts"] == [
"low",
"medium",
"high",
]
assert any(m["id"] == "claude-sonnet-4-6" and m["efforts"] == [] for m in models)
codex = provider_row("openai-codex")
assert codex is not None
assert codex.to_dict()["curated_models"][0]["efforts"][-1] == "ultra"
# ------------------------------------------------------------ Anthropic API effort
def test_anthropic_adapter_effort_and_temperature_rules():
# Claude 5 / 4.x families: no temperature.
for model in ("claude-fable-5", "claude-opus-5", "claude-sonnet-5", "claude-opus-4-8"):
assert _is_reasoning_model(model), model
assert not _is_reasoning_model("claude-3-5-sonnet-20241022")
# No effort requested -> nothing added (the voice brain's requests stay as they were).
assert reasoning_kwargs("claude-opus-5", None) == {}
assert reasoning_kwargs("claude-opus-5", "") == {}
# Effort -> output_config.effort + adaptive thinking on the models that take it.
assert reasoning_kwargs("claude-opus-5", "xhigh") == {
"output_config": {"effort": "xhigh"},
"thinking": {"type": "adaptive"},
}
# Opus 4.6 has no xhigh: snaps to high; Opus 4.5 tops out at high.
assert reasoning_kwargs("claude-opus-4-6", "xhigh")["output_config"] == {"effort": "high"}
assert reasoning_kwargs("claude-opus-4-5", "max")["output_config"] == {"effort": "high"}
assert "thinking" not in reasoning_kwargs("claude-opus-4-5", "max")
# Haiku 4.5 rejects the parameter: nothing is sent.
assert reasoning_kwargs("claude-haiku-4-5-20251001", "high") == {}
# none/minimal mean "as little as possible" -> the lowest rung.
assert reasoning_kwargs("claude-sonnet-5", "none")["output_config"] == {"effort": "low"}