mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-07-31 19:16:29 +00:00
232 lines
8.6 KiB
Python
232 lines
8.6 KiB
Python
"""Single-owner /model parsing + effective-model resolution tests.
|
|
|
|
Covers the consolidation of the 7 historical parsing/resolution variants
|
|
into hermes_cli.model_switch (parse_model_switch_args +
|
|
resolve_effective_model), including the 7dd00bb47d regression class
|
|
(api_server discarding session-persisted models) as a permanent parity
|
|
test against the pre-consolidation logic captured from origin/main.
|
|
|
|
Real imports throughout (AGENTS.md: no mocks for resolution chains).
|
|
"""
|
|
|
|
import pytest
|
|
|
|
from hermes_cli.model_switch import (
|
|
MODEL_SWITCH_ERR_ONCE_REQUIRES_TARGET,
|
|
MODEL_SWITCH_ERR_ONCE_WITH_GLOBAL,
|
|
MODEL_SWITCH_ERROR_TEXT,
|
|
ModelSwitchRequest,
|
|
parse_model_flags_detailed,
|
|
parse_model_switch_args,
|
|
resolve_effective_model,
|
|
)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# parse_model_switch_args — the ONE parser
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_bare_name_on_aggregator_passes_through():
|
|
# Bare names are NOT provider-qualified by the parser: aggregator-aware
|
|
# resolution (bare names resolve WITHIN the aggregator first, via
|
|
# switch_model's catalog search) happens downstream. The parser must not
|
|
# hardcode a provider.
|
|
req = parse_model_switch_args("sonnet")
|
|
assert req.target == "sonnet"
|
|
assert req.explicit_provider == ""
|
|
assert req.scope == "default"
|
|
assert req.errors == ()
|
|
|
|
|
|
def test_provider_colon_model_target_preserved():
|
|
# vendor:model colon forms are preserved verbatim — switch_model converts
|
|
# them to aggregator slugs only when the current provider is an aggregator.
|
|
req = parse_model_switch_args("anthropic:claude-sonnet-4-5")
|
|
assert req.target == "anthropic:claude-sonnet-4-5"
|
|
assert req.explicit_provider == ""
|
|
|
|
|
|
def test_provider_flag_and_scopes():
|
|
req = parse_model_switch_args("sonnet --provider anthropic --global")
|
|
assert req.target == "sonnet"
|
|
assert req.explicit_provider == "anthropic"
|
|
assert req.is_global is True
|
|
assert req.scope == "global"
|
|
assert req.errors == ()
|
|
|
|
assert parse_model_switch_args("sonnet --session").scope == "session"
|
|
assert parse_model_switch_args("sonnet --once").scope == "once"
|
|
assert parse_model_switch_args("--refresh").force_refresh is True
|
|
|
|
|
|
def test_once_with_global_conflict():
|
|
req = parse_model_switch_args("sonnet --once --global")
|
|
assert MODEL_SWITCH_ERR_ONCE_WITH_GLOBAL in req.errors
|
|
assert (
|
|
MODEL_SWITCH_ERROR_TEXT[MODEL_SWITCH_ERR_ONCE_WITH_GLOBAL]
|
|
== "/model --once cannot be combined with --global"
|
|
)
|
|
assert "/model --once cannot be combined with --global" in req.error_messages()
|
|
|
|
|
|
def test_once_without_target_error():
|
|
req = parse_model_switch_args("--once")
|
|
assert MODEL_SWITCH_ERR_ONCE_REQUIRES_TARGET in req.errors
|
|
assert (
|
|
MODEL_SWITCH_ERROR_TEXT[MODEL_SWITCH_ERR_ONCE_REQUIRES_TARGET]
|
|
== "/model --once requires a model or provider."
|
|
)
|
|
# --once with just a provider is valid.
|
|
assert parse_model_switch_args("--once --provider anthropic").errors == ()
|
|
|
|
|
|
def test_unicode_dash_normalization_matches_legacy_parser():
|
|
# Telegram/iOS auto-converts "--" to em dashes; the shared parser must
|
|
# keep the legacy normalization.
|
|
req = parse_model_switch_args("sonnet \u2014global")
|
|
assert req.is_global is True
|
|
assert req.target == "sonnet"
|
|
|
|
|
|
def test_request_is_compatible_with_flag_result_consumers():
|
|
# tui_gateway._apply_model_switch duck-types on .model_input; the request
|
|
# object must satisfy the same consumer surface.
|
|
req = parse_model_switch_args("sonnet --provider anthropic --once")
|
|
assert req.model_input == "sonnet"
|
|
legacy = parse_model_flags_detailed("sonnet --provider anthropic --once")
|
|
assert req.flags == legacy
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# resolve_effective_model — session > channel/session-persisted > global
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class _ChannelOverride:
|
|
def __init__(self, model):
|
|
self.model = model
|
|
|
|
|
|
def test_session_override_beats_channel_and_global():
|
|
assert (
|
|
resolve_effective_model({"model": "session-model"}, _ChannelOverride("chan-model"), "global-model")
|
|
== "session-model"
|
|
)
|
|
|
|
|
|
def test_channel_beats_global_when_no_session():
|
|
assert (
|
|
resolve_effective_model(None, _ChannelOverride("chan-model"), "global-model")
|
|
== "chan-model"
|
|
)
|
|
assert resolve_effective_model({}, _ChannelOverride(""), "global-model") == "global-model"
|
|
|
|
|
|
def test_global_fallback_and_empty():
|
|
assert resolve_effective_model(None, None, "global-model") == "global-model"
|
|
assert resolve_effective_model(None, None, "") == ""
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Parity: run.py-style channel resolution (old logic from origin/main)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _old_run_py_resolve(override, global_model):
|
|
# Captured from origin/main gateway/run.py:_resolve_model_for_channel:
|
|
# if override and override.model:
|
|
# return override.model
|
|
# return _resolve_gateway_model(user_config)
|
|
if override and override.model:
|
|
return override.model
|
|
return global_model
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"override,global_model",
|
|
[
|
|
(None, "global-model"),
|
|
(_ChannelOverride("chan-model"), "global-model"),
|
|
(_ChannelOverride(""), "global-model"),
|
|
(_ChannelOverride("chan-model"), ""),
|
|
(None, ""),
|
|
],
|
|
)
|
|
def test_run_py_channel_resolution_parity(override, global_model):
|
|
assert resolve_effective_model(None, override, global_model) == _old_run_py_resolve(
|
|
override, global_model
|
|
)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Parity: api_server-style resolution (old logic from origin/main)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _clean(value):
|
|
# api_server._clean_request_string equivalent for the parity harness.
|
|
if value is None:
|
|
return None
|
|
text = str(value).strip()
|
|
return text or None
|
|
|
|
|
|
def _old_api_server_resolve(session_override, session_row_model, global_model):
|
|
# Captured from origin/main gateway/platforms/api_server.py:_create_agent
|
|
# (post-7dd00bb47d — session /model override > session-persisted model >
|
|
# global default):
|
|
model = global_model
|
|
if session_override:
|
|
model = (_clean(session_override.get("model")) or model)
|
|
elif _clean(session_row_model):
|
|
model = _clean(session_row_model)
|
|
return model
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"session_override,session_row_model,global_model",
|
|
[
|
|
(None, None, "global-model"),
|
|
(None, "session-persisted", "global-model"), # the 7dd00bb47d regression
|
|
({"model": "override-model"}, "session-persisted", "global-model"),
|
|
({"model": ""}, "session-persisted", "global-model"),
|
|
({"model": "override-model"}, None, "global-model"),
|
|
(None, " ", "global-model"),
|
|
],
|
|
)
|
|
def test_api_server_resolution_parity(session_override, session_row_model, global_model):
|
|
# New logic mirrors the migrated api_server code path exactly:
|
|
if session_override:
|
|
new = resolve_effective_model(session_override, None, global_model)
|
|
elif _clean(session_row_model):
|
|
new = resolve_effective_model(None, session_row_model, global_model)
|
|
else:
|
|
new = global_model
|
|
assert new == _old_api_server_resolve(session_override, session_row_model, global_model)
|
|
|
|
|
|
def test_session_persisted_model_honored_by_both_surfaces():
|
|
"""Permanent 7dd00bb47d regression test.
|
|
|
|
A session-persisted model (POST /api/sessions {"model": ...} on the API
|
|
server; per-channel/session config on the native gateway) must be honored
|
|
over the global default by BOTH resolution styles — the divergence class
|
|
this consolidation kills.
|
|
"""
|
|
session_persisted = "vendor/session-pinned-model"
|
|
global_model = "vendor/global-default"
|
|
|
|
# run.py-style: channel/session tier vs global.
|
|
assert (
|
|
resolve_effective_model(None, session_persisted, global_model)
|
|
== session_persisted
|
|
)
|
|
# api_server-style: same shared owner, same answer.
|
|
assert (
|
|
resolve_effective_model(None, {"model": session_persisted}, global_model)
|
|
== session_persisted
|
|
)
|
|
# And an explicit session /model override still beats both.
|
|
assert (
|
|
resolve_effective_model(
|
|
{"model": "vendor/live-override"}, session_persisted, global_model
|
|
)
|
|
== "vendor/live-override"
|
|
)
|