mirrors/hermes-agent
1
0
Fork 0
mirror of https://github.com/NousResearch/hermes-agent.git synced 2026-07-24 16:54:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
hermes-agent/tests/hermes_cli/test_moa_config.py
Teknium 23476207bc feat(moa): default advisor fanout to user_turn — the cheapest cadence 
Flips the default fan-out cadence from per_iteration (advisors re-run on
every tool iteration, multiplying advisor spend by tool-loop depth) to
user_turn (advisors run once on the first message of each user turn; the
acting aggregator works the rest of the tool loop with that turn's
advice). Until per-mode benchmarks justify a costlier default, MoA
defaults to the cheapest, lowest-impact cadence (#67199).

One default for everyone — no split legacy/new-preset semantics; presets
that want per-step advising set fanout: per_iteration explicitly. All
three modes (user_turn / per_iteration / every_n:N) remain selectable;
every_n:1 still collapses to per_iteration (semantic identity), while
unparseable values now fall to user_turn (the default).

Docs updated with a default-change note; the per-iteration rerun test
pins its mode explicitly.

Co-authored-by: skyer-flyyy <188930297+skyer-flyyy@users.noreply.github.com>
2026-07-23 21:07:18 -07:00

776 lines
29 KiB
Python
Raw Permalink Blame History

import pytest
from agent.errors import MoAPresetNotFoundError
from hermes_cli.moa_config import (
DEFAULT_MOA_AGGREGATOR,
DEFAULT_MOA_PRESET_NAME,
DEFAULT_MOA_REFERENCE_MODELS,
build_moa_turn_prompt,
decode_moa_turn,
exact_moa_preset_name,
normalize_moa_config,
resolve_moa_preset,
set_active_moa_preset,
)
def test_moa_slot_picker_excludes_unconfigured_providers(monkeypatch):
from hermes_cli import moa_cmd
captured = {}
monkeypatch.setattr(moa_cmd, "load_picker_context", lambda: object())
def fake_build(_context, **kwargs):
captured.update(kwargs)
return {
"providers": [
{"slug": "moa", "models": ["default"]},
{"slug": "opencode-go", "models": ["deepseek-v4-pro"]},
]
}
monkeypatch.setattr(moa_cmd, "build_models_payload", fake_build)
assert [row["slug"] for row in moa_cmd._model_options()] == ["opencode-go"]
assert captured["include_unconfigured"] is False
def _enabled_refs(refs):
return [{**slot, "enabled": True} for slot in refs]
def test_normalize_moa_config_uses_default_named_preset():
cfg = normalize_moa_config({})
assert cfg["default_preset"] == DEFAULT_MOA_PRESET_NAME
assert list(cfg["presets"]) == [DEFAULT_MOA_PRESET_NAME]
assert cfg["reference_models"] == _enabled_refs(DEFAULT_MOA_REFERENCE_MODELS)
assert cfg["aggregator"] == DEFAULT_MOA_AGGREGATOR
def test_normalize_moa_config_preserves_named_presets():
cfg = normalize_moa_config(
{
"default_preset": "coding",
"presets": {
"coding": {
"reference_models": [{"provider": "openai-codex", "model": "gpt-5.5"}],
"aggregator": {"provider": "openrouter", "model": "anthropic/claude-opus-4.8"},
},
"review": {
"reference_models": [{"provider": "openrouter", "model": "deepseek/deepseek-v4-pro"}],
"aggregator": {"provider": "openrouter", "model": "anthropic/claude-opus-4.8"},
},
},
}
)
assert cfg["default_preset"] == "coding"
assert set(cfg["presets"]) == {"coding", "review"}
assert cfg["reference_models"] == [{"provider": "openai-codex", "model": "gpt-5.5", "enabled": True}]
def test_normalize_moa_config_defaults_reference_enabled_true():
cfg = normalize_moa_config(
{
"presets": {
"review": {
"reference_models": [{"provider": "openrouter", "model": "deepseek/deepseek-v4-pro"}],
"aggregator": {"provider": "openrouter", "model": "anthropic/claude-opus-4.8"},
}
}
}
)
assert cfg["presets"]["review"]["reference_models"] == [
{"provider": "openrouter", "model": "deepseek/deepseek-v4-pro", "enabled": True}
]
def test_normalize_moa_config_preserves_disabled_reference():
cfg = normalize_moa_config(
{
"presets": {
"review": {
"reference_models": [
{"provider": "openai-codex", "model": "gpt-5.5", "enabled": False},
{"provider": "openrouter", "model": "deepseek/deepseek-v4-pro", "enabled": "false"},
],
"aggregator": {"provider": "openrouter", "model": "anthropic/claude-opus-4.8"},
}
}
}
)
assert cfg["presets"]["review"]["reference_models"] == [
{"provider": "openai-codex", "model": "gpt-5.5", "enabled": False},
{"provider": "openrouter", "model": "deepseek/deepseek-v4-pro", "enabled": False},
]
def test_legacy_flat_config_becomes_default_preset():
cfg = normalize_moa_config(
{
"reference_models": [{"provider": "openai-codex", "model": "gpt-5.5"}],
"aggregator": {"provider": "openrouter", "model": "anthropic/claude-opus-4.8"},
}
)
assert cfg["presets"][DEFAULT_MOA_PRESET_NAME]["reference_models"] == [
{"provider": "openai-codex", "model": "gpt-5.5", "enabled": True}
]
def test_normalize_moa_config_tolerates_non_numeric_values():
"""Non-numeric strings in hand-edited config.yaml must degrade to defaults
instead of crashing normalize_moa_config with ValueError."""
cfg = normalize_moa_config(
{
"presets": {
"broken": {
"max_tokens": "notanumber",
"reference_temperature": "hot",
"aggregator_temperature": "",
}
}
}
)
preset = cfg["presets"]["broken"]
assert preset["max_tokens"] == 4096
# Unparseable/blank temperatures degrade to None = "don't send the
# parameter; provider default applies" (matching single-model behavior),
# not to a hardcoded sampling value.
assert preset["reference_temperature"] is None
assert preset["aggregator_temperature"] is None
def test_normalize_moa_config_tolerates_non_list_reference_models():
"""A hand-edited scalar reference_models must degrade to defaults instead of
crashing normalize_moa_config with TypeError (symmetric with the non-numeric
scalar-field tolerance)."""
cfg = normalize_moa_config(
{"presets": {"broken": {"reference_models": 2}}}
)
assert cfg["presets"]["broken"]["reference_models"] == _enabled_refs(DEFAULT_MOA_REFERENCE_MODELS)
def test_normalize_moa_config_wraps_bare_dict_reference_models():
"""A single reference slot written without the list wrapper is rescued."""
cfg = normalize_moa_config(
{"presets": {"p": {"reference_models": {"provider": "openai", "model": "gpt-4o"}}}}
)
assert cfg["presets"]["p"]["reference_models"] == [{"provider": "openai", "model": "gpt-4o", "enabled": True}]
def test_normalize_moa_config_parses_json_string_reference_models():
"""reference_models stored as a JSON string (hand-edited config.yaml or a
stringified GUI save) must round-trip to the parsed model list instead of
being discarded for defaults."""
import json
models = [
{"provider": "openai", "model": "gpt-4o"},
{"provider": "anthropic", "model": "claude-sonnet-4"},
]
cfg = normalize_moa_config(
{"presets": {"p": {"reference_models": json.dumps(models)}}}
)
assert cfg["presets"]["p"]["reference_models"] == [
{**m, "enabled": True} for m in models
]
def test_normalize_moa_config_malformed_json_string_falls_back_to_defaults():
"""A malformed JSON string reference_models must degrade to the default
reference models without raising."""
cfg = normalize_moa_config(
{"presets": {"p": {"reference_models": "[{'provider': broken"}}}
)
assert cfg["presets"]["p"]["reference_models"] == [
{**m, "enabled": True} for m in DEFAULT_MOA_REFERENCE_MODELS
]
def test_normalize_moa_config_preserves_slot_reasoning_effort():
cfg = normalize_moa_config(
{
"presets": {
"p": {
"reference_models": [
{"provider": "openai-codex", "model": "gpt-5.6-sol", "reasoning_effort": "LOW"},
{"provider": "openai-codex", "model": "gpt-5.6-sol", "reasoning_effort": False},
{"provider": "openai-codex", "model": "gpt-5.6-sol", "reasoning_effort": "nonsense"},
{"provider": "openai-codex", "model": "gpt-5.6-sol", "reasoning_effort": "ultra"},
],
"aggregator": {"provider": "openai-codex", "model": "gpt-5.6-sol", "reasoning_effort": "xhigh"},
}
}
}
)
preset = cfg["presets"]["p"]
assert preset["reference_models"][0]["reasoning_effort"] == "low"
assert preset["reference_models"][1]["reasoning_effort"] == "none"
assert "reasoning_effort" not in preset["reference_models"][2]
assert preset["reference_models"][3]["reasoning_effort"] == "ultra"
assert preset["aggregator"]["reasoning_effort"] == "xhigh"
def test_normalize_moa_config_round_trips_reasoning_effort_and_enabled():
"""Regression: a client that GETs the config and PUTs it straight back must
not strip per-slot keys. reasoning_effort AND enabled have to survive a
normalize → normalize round trip together (a save path that re-normalizes
the previously normalized payload is the exact client round-trip shape)."""
cfg = normalize_moa_config(
{
"presets": {
"p": {
"reference_models": [
{"provider": "openai-codex", "model": "gpt-5.5", "reasoning_effort": "high", "enabled": False},
{"provider": "openrouter", "model": "deepseek/deepseek-v4-pro", "enabled": True},
],
"aggregator": {
"provider": "openrouter",
"model": "anthropic/claude-opus-4.8",
"reasoning_effort": "xhigh",
},
}
}
}
)
round_tripped = normalize_moa_config(cfg)
refs = round_tripped["presets"]["p"]["reference_models"]
assert refs[0] == {
"provider": "openai-codex",
"model": "gpt-5.5",
"reasoning_effort": "high",
"enabled": False,
}
assert refs[1] == {"provider": "openrouter", "model": "deepseek/deepseek-v4-pro", "enabled": True}
assert round_tripped["presets"]["p"]["aggregator"]["reasoning_effort"] == "xhigh"
def test_normalize_moa_config_coerces_numeric_strings():
"""Valid numeric strings (e.g. from YAML round-trip) must coerce correctly."""
cfg = normalize_moa_config({"max_tokens": "8192", "reference_temperature": "0.9"})
preset = cfg["presets"][DEFAULT_MOA_PRESET_NAME]
assert preset["max_tokens"] == 8192
assert preset["reference_temperature"] == 0.9
def test_normalize_moa_config_coerces_float_max_tokens():
"""max_tokens: 4096.0 (float from YAML) must coerce to int."""
cfg = normalize_moa_config({"max_tokens": 4096.0})
assert cfg["presets"][DEFAULT_MOA_PRESET_NAME]["max_tokens"] == 4096
cfg2 = normalize_moa_config({"max_tokens": "4096.5"})
assert cfg2["presets"][DEFAULT_MOA_PRESET_NAME]["max_tokens"] == 4096
def test_exact_preset_matching_is_not_fuzzy():
config = {"presets": {"coding": {}, "review": {}}}
assert exact_moa_preset_name(config, "coding") == "coding"
assert exact_moa_preset_name(config, "cod") is None
assert exact_moa_preset_name(config, "coding please fix this") is None
def test_exact_preset_matching_skips_disabled_presets():
"""A disabled preset must not match the implicit bare-name switch path.
Regression for #55187: with ``enabled: false`` presets, a plain model
switch whose name collides with a preset key (e.g. ``default``) silently
pivoted the session onto the MoA virtual provider. The per-preset
``enabled`` opt-out must gate this implicit match.
"""
config = {
"presets": {
"default": {"enabled": False},
"klo": {"enabled": False},
},
}
assert exact_moa_preset_name(config, "default") is None
assert exact_moa_preset_name(config, "klo") is None
def test_exact_preset_matching_allows_enabled_presets():
"""An explicitly enabled preset still matches the bare-name switch path."""
config = {
"presets": {
"fast": {"enabled": True},
"slow": {"enabled": False},
},
}
assert exact_moa_preset_name(config, "fast") == "fast"
assert exact_moa_preset_name(config, "slow") is None
# Default (no explicit enabled key) is enabled and still matches.
assert exact_moa_preset_name({"presets": {"x": {}}}, "x") == "x"
def test_active_preset_toggle_validation():
config = {"default_preset": "coding", "presets": {"coding": {}, "review": {}}}
active = set_active_moa_preset(config, "review")
assert active["active_preset"] == "review"
inactive = set_active_moa_preset(active, "")
assert inactive["active_preset"] == ""
def test_resolve_moa_preset_returns_requested_model_set():
cfg = normalize_moa_config(
{
"presets": {
"coding": {"reference_models": [{"provider": "openai-codex", "model": "gpt-5.5"}]},
"review": {"reference_models": [{"provider": "openrouter", "model": "deepseek/deepseek-v4-pro"}]},
}
}
)
assert resolve_moa_preset(cfg, "review")["reference_models"] == [
{"provider": "openrouter", "model": "deepseek/deepseek-v4-pro", "enabled": True}
]
def test_resolve_missing_moa_preset_has_actionable_error():
cfg = {
"default_preset": "日常对话-高峰",
"presets": {"日常对话-高峰": {}, "日常对话-非高峰": {}},
}
with pytest.raises(MoAPresetNotFoundError) as exc_info:
resolve_moa_preset(cfg, "日常对话-高峰期")
message = str(exc_info.value)
assert "日常对话-高峰期" in message
assert "日常对话-高峰" in message
assert "日常对话-非高峰" in message
assert "hermes moa list" in message
def test_resolve_missing_moa_preset_does_not_silently_fallback():
cfg = {
"default_preset": "日常对话-高峰",
"presets": {"日常对话-高峰": {}},
}
with pytest.raises(MoAPresetNotFoundError):
resolve_moa_preset(cfg, "renamed-preset")
def test_missing_moa_preset_is_non_retryable():
from agent.error_classifier import FailoverReason, classify_api_error
result = classify_api_error(
MoAPresetNotFoundError("MoA preset 'old' was not found"),
provider="moa",
model="old",
)
assert result.reason == FailoverReason.model_not_found
assert result.retryable is False
assert result.should_fallback is False
def test_build_moa_turn_prompt_encodes_one_shot_default_preset():
prompt = build_moa_turn_prompt("write a file then inspect it")
decoded_prompt, cfg = decode_moa_turn(prompt)
assert decoded_prompt == "write a file then inspect it"
assert cfg is not None
assert cfg["reference_models"] == _enabled_refs(DEFAULT_MOA_REFERENCE_MODELS)
def test_moa_provider_rejected_as_reference_slot():
"""A reference slot pointing at the moa virtual provider is dropped, so a
preset cannot recursively reference another MoA run."""
cfg = normalize_moa_config(
{
"presets": {
"p": {
"reference_models": [
{"provider": "moa", "model": "default"},
{"provider": "openrouter", "model": "deepseek/deepseek-v4-pro"},
],
"aggregator": {"provider": "openrouter", "model": "anthropic/claude-opus-4.8"},
}
}
}
)
refs = cfg["presets"]["p"]["reference_models"]
assert {"provider": "moa", "model": "default"} not in refs
assert refs == [{"provider": "openrouter", "model": "deepseek/deepseek-v4-pro", "enabled": True}]
def test_moa_provider_rejected_as_aggregator_slot():
"""An aggregator slot pointing at the moa virtual provider is dropped and
falls back to the default aggregator, never a recursive MoA aggregator."""
cfg = normalize_moa_config(
{
"presets": {
"p": {
"reference_models": [{"provider": "openrouter", "model": "deepseek/deepseek-v4-pro"}],
"aggregator": {"provider": "moa", "model": "default"},
}
}
}
)
agg = cfg["presets"]["p"]["aggregator"]
assert agg["provider"] != "moa"
assert agg == DEFAULT_MOA_AGGREGATOR
def test_moa_provider_rejected_case_insensitive():
"""Case variants like ``MoA`` are also blocked."""
cfg = normalize_moa_config(
{"presets": {"p": {"aggregator": {"provider": "MoA", "model": "default"}}}}
)
assert cfg["presets"]["p"]["aggregator"]["provider"] != "moa"
assert cfg["presets"]["p"]["aggregator"] == DEFAULT_MOA_AGGREGATOR
def _preset(**extra):
base = {
"reference_models": [{"provider": "openrouter", "model": "anthropic/claude-opus-4.8"}],
"aggregator": {"provider": "openrouter", "model": "anthropic/claude-opus-4.8"},
}
base.update(extra)
return {"default_preset": "p", "presets": {"p": base}}
def test_reference_max_tokens_defaults_to_none_uncapped():
"""Unset reference_max_tokens resolves to None (no cap) so existing presets
keep their prior uncapped advisor behavior — no silent regression."""
p = resolve_moa_preset(_preset(), "p")
assert p["reference_max_tokens"] is None
def test_reference_max_tokens_positive_value_preserved():
"""A positive cap flows through resolve_moa_preset to the runtime path."""
p = resolve_moa_preset(_preset(reference_max_tokens=600), "p")
assert p["reference_max_tokens"] == 600
def test_reference_max_tokens_invalid_falls_back_to_none():
"""Non-positive / non-numeric caps degrade to None (uncapped) rather than
clamping advisors to a nonsense value or crashing."""
for bad in (0, -5, "abc", "", None):
p = resolve_moa_preset(_preset(reference_max_tokens=bad), "p")
assert p["reference_max_tokens"] is None, bad
def test_reference_max_tokens_string_number_coerced():
"""A hand-edited config.yaml string like '600' coerces to int."""
p = resolve_moa_preset(_preset(reference_max_tokens="600"), "p")
assert p["reference_max_tokens"] == 600
def test_reference_max_tokens_in_flattened_view():
"""The flattened compatibility view (dashboard/desktop callers) exposes the
active preset's reference_max_tokens."""
cfg = normalize_moa_config(_preset(reference_max_tokens=750))
assert cfg["reference_max_tokens"] == 750
# ── validate_moa_payload (write-boundary validation, #64156) ─────────────────
#
# normalize_moa_config is deliberately tolerant at READ time (hand-edited
# configs degrade to defaults). validate_moa_payload is the strict WRITE-time
# counterpart: it must flag exactly the payloads normalize would silently
# repair, so API save paths reject them instead of corrupting user config.
def _valid_preset_payload():
return {
"reference_models": [{"provider": "openrouter", "model": "deepseek/deepseek-v4-pro"}],
"aggregator": {"provider": "openrouter", "model": "anthropic/claude-opus-4.8"},
}
def test_validate_moa_payload_accepts_complete_presets():
from hermes_cli.moa_config import validate_moa_payload
assert validate_moa_payload({"presets": {"default": _valid_preset_payload()}}) == []
def test_validate_moa_payload_accepts_legacy_flat_payload():
from hermes_cli.moa_config import validate_moa_payload
assert validate_moa_payload(_valid_preset_payload()) == []
def test_validate_moa_payload_flags_half_filled_reference_slot():
"""The #64156 shape: provider picked, model still empty (mid-edit autosave)."""
from hermes_cli.moa_config import validate_moa_payload
preset = _valid_preset_payload()
preset["reference_models"].append({"provider": "kilo", "model": ""})
problems = validate_moa_payload({"presets": {"default": preset}})
assert problems
assert any("reference 2" in p and "model is required" in p for p in problems)
def test_validate_moa_payload_flags_half_filled_aggregator():
from hermes_cli.moa_config import validate_moa_payload
preset = _valid_preset_payload()
preset["aggregator"] = {"provider": "openrouter", "model": ""}
problems = validate_moa_payload({"presets": {"default": preset}})
assert any("aggregator" in p and "model is required" in p for p in problems)
def test_validate_moa_payload_flags_empty_references():
from hermes_cli.moa_config import validate_moa_payload
preset = _valid_preset_payload()
preset["reference_models"] = []
problems = validate_moa_payload({"presets": {"default": preset}})
assert any("at least one complete reference model" in p for p in problems)
def test_validate_moa_payload_flags_recursive_moa_slot():
from hermes_cli.moa_config import validate_moa_payload
preset = _valid_preset_payload()
preset["aggregator"] = {"provider": "MoA", "model": "default"}
problems = validate_moa_payload({"presets": {"default": preset}})
assert any("recursive MoA" in p for p in problems)
def test_validate_moa_payload_names_the_broken_preset():
"""Multi-preset payloads must say WHICH preset is broken."""
from hermes_cli.moa_config import validate_moa_payload
problems = validate_moa_payload(
{
"presets": {
"good": _valid_preset_payload(),
"broken": {
"reference_models": [{"provider": "", "model": ""}],
"aggregator": {"provider": "a", "model": "b"},
},
}
}
)
assert problems
assert all("'broken'" in p for p in problems)
assert not any("'good'" in p for p in problems)
def test_validate_moa_payload_agrees_with_clean_slot():
"""Contract: a payload validate accepts must survive normalize UNCHANGED in
its slots — validate and _clean_slot can never disagree (else a payload
could pass validation and still be swapped for defaults)."""
from hermes_cli.moa_config import validate_moa_payload
payload = {"presets": {"p": _valid_preset_payload()}}
assert validate_moa_payload(payload) == []
cfg = normalize_moa_config(payload)
# Slots survive with only the canonical enabled=True default added — no
# provider/model swap, no defaults substitution.
assert cfg["presets"]["p"]["reference_models"] == _enabled_refs(payload["presets"]["p"]["reference_models"])
assert cfg["presets"]["p"]["aggregator"] == payload["presets"]["p"]["aggregator"]
def test_validate_moa_payload_rejects_non_dict():
from hermes_cli.moa_config import validate_moa_payload
assert validate_moa_payload(None)
assert validate_moa_payload([1, 2])
assert validate_moa_payload({"presets": {"p": "not-a-dict"}})
# ── Per-slot max_tokens ────────────────────────────────────────────────────
def test_slot_max_tokens_preserved():
"""A max_tokens field on a reference slot survives normalization."""
cfg = normalize_moa_config(
{
"presets": {
"p": {
"reference_models": [
{"provider": "openrouter", "model": "deepseek/deepseek-v4-pro", "max_tokens": 600},
{"provider": "openai-codex", "model": "gpt-5.5"},
],
"aggregator": {"provider": "openrouter", "model": "anthropic/claude-opus-4.8"},
}
}
}
)
refs = cfg["presets"]["p"]["reference_models"]
assert refs[0] == {"provider": "openrouter", "model": "deepseek/deepseek-v4-pro", "max_tokens": 600, "enabled": True}
assert refs[1] == {"provider": "openai-codex", "model": "gpt-5.5", "enabled": True}
def test_slot_max_tokens_coerced_from_string():
"""Hand-edited YAML string '600' coerces to int on a slot."""
cfg = normalize_moa_config(
{
"presets": {
"p": {
"reference_models": [
{"provider": "openrouter", "model": "deepseek/deepseek-v4-pro", "max_tokens": "600"},
],
}
}
}
)
refs = cfg["presets"]["p"]["reference_models"]
assert refs[0]["max_tokens"] == 600
def test_slot_max_tokens_invalid_dropped():
"""Non-positive / non-numeric slot max_tokens is dropped (slot kept)."""
for bad in (0, -5, "abc", "", None):
cfg = normalize_moa_config(
{
"presets": {
"p": {
"reference_models": [
{"provider": "openrouter", "model": "deepseek/deepseek-v4-pro", "max_tokens": bad},
],
}
}
}
)
ref = cfg["presets"]["p"]["reference_models"][0]
assert "max_tokens" not in ref, bad
assert ref["provider"] == "openrouter"
def test_slot_max_tokens_absent_by_default():
"""Slots without max_tokens don't get the field — backward compat."""
cfg = normalize_moa_config(
{
"presets": {
"p": {
"reference_models": [
{"provider": "openrouter", "model": "deepseek/deepseek-v4-pro"},
],
}
}
}
)
ref = cfg["presets"]["p"]["reference_models"][0]
assert "max_tokens" not in ref
# --- fanout cadence normalization (every_n) ---
def test_fanout_defaults_to_user_turn():
# Default is the cheapest cadence (#67199): advisors once per user turn.
cfg = normalize_moa_config({})
assert cfg["fanout"] == "user_turn"
def test_fanout_per_iteration_still_selectable():
cfg = normalize_moa_config({"fanout": "per_iteration"})
assert cfg["fanout"] == "per_iteration"
def test_fanout_every_n_string_form_normalized():
cfg = normalize_moa_config({"fanout": "every_n:3"})
assert cfg["fanout"] == "every_n:3"
assert cfg["presets"][DEFAULT_MOA_PRESET_NAME]["fanout"] == "every_n:3"
def test_fanout_every_n_mapping_form_normalized_to_string():
cfg = normalize_moa_config({"fanout": {"mode": "every_n", "n": 4}})
assert cfg["fanout"] == "every_n:4"
def test_fanout_every_n_degenerate_n_falls_back():
# n=1 means "every iteration" — that semantically IS per_iteration;
# n=0 / negative / garbage is unparseable and falls to the default
# cadence (user_turn, the cheapest — #67199).
assert normalize_moa_config({"fanout": "every_n:1"})["fanout"] == "per_iteration"
assert normalize_moa_config({"fanout": "every_n:0"})["fanout"] == "user_turn"
assert normalize_moa_config({"fanout": "every_n:-2"})["fanout"] == "user_turn"
assert normalize_moa_config({"fanout": "every_n:x"})["fanout"] == "user_turn"
assert normalize_moa_config({"fanout": "every_n"})["fanout"] == "user_turn"
assert normalize_moa_config({"fanout": {"mode": "every_n"}})["fanout"] == "user_turn"
def test_fanout_every_n_round_trips_through_normalize():
once = normalize_moa_config({"fanout": "every_n:3"})
twice = normalize_moa_config(once)
assert twice["fanout"] == "every_n:3"
assert twice["presets"][DEFAULT_MOA_PRESET_NAME]["fanout"] == "every_n:3"
def test_fanout_mapping_user_turn_mode_accepted():
cfg = normalize_moa_config({"fanout": {"mode": "user_turn"}})
assert cfg["fanout"] == "user_turn"
# --- privacy_filter normalization ---
def test_privacy_filter_defaults_off():
cfg = normalize_moa_config({})
assert cfg["privacy_filter"] == ""
def test_privacy_filter_modes_normalized():
from hermes_cli.moa_config import coerce_privacy_filter
assert coerce_privacy_filter("display") == "display"
assert coerce_privacy_filter("FULL") == "full"
assert coerce_privacy_filter(True) == "full" # legacy boolean → issue #59959 ask
assert coerce_privacy_filter("true") == "full"
assert coerce_privacy_filter(False) == ""
assert coerce_privacy_filter(None) == ""
assert coerce_privacy_filter("bogus") == ""
assert coerce_privacy_filter("off") == ""
def test_privacy_filter_round_trips_through_normalize():
once = normalize_moa_config({"privacy_filter": "display"})
assert once["privacy_filter"] == "display"
assert normalize_moa_config(once)["privacy_filter"] == "display"
full = normalize_moa_config({"privacy_filter": "full"})
assert normalize_moa_config(full)["privacy_filter"] == "full"
def test_reference_failure_controls_are_normalized_per_preset_and_flattened():
cfg = normalize_moa_config(
_preset(reference_timeout="120.5", degraded_reference_policy="silent")
)
preset = cfg["presets"]["p"]
assert preset["reference_timeout"] == 120.5
assert preset["degraded_reference_policy"] == "silent"
assert cfg["reference_timeout"] == 120.5
assert cfg["degraded_reference_policy"] == "silent"
@pytest.mark.parametrize("value", [None, "", 0, -1, "bad"])
def test_reference_timeout_invalid_values_fall_back_to_default(value):
# None = inherit auxiliary.moa_reference.timeout (no per-preset override).
assert resolve_moa_preset(_preset(reference_timeout=value), "p")["reference_timeout"] is None
def test_reference_timeout_is_uncapped_and_unknown_policy_is_loud():
preset = resolve_moa_preset(
_preset(reference_timeout=9999, degraded_reference_policy="wat"), "p"
)
# Explicit per-preset values are honored as-is — long-thinking advisor
# models legitimately run beyond any fixed cap.
assert preset["reference_timeout"] == 9999.0
assert preset["degraded_reference_policy"] == "loud"
Reference in a new issue View git blame Copy permalink