Fearvox
3d1d0a49fe
The minimax / minimax-cn / minimax-oauth profiles still advertised
M2.7 (and M2.7-highspeed for OAuth) as their default_aux_model,
predating the M3 release (2026-06-01). The user-facing
_PROVIDER_MODELS['minimax'] catalog top entry is M3, and the
recommended config for a Token-Plan install now sets
model.default: MiniMax-M3, so the aux default was the only
remaining drift.
Updates:
* minimax default_aux_model: M2.7 -> M3
* minimax-cn default_aux_model: M2.7 -> M3
* minimax-oauth default_aux_model: M2.7-highspeed -> M2.7
(M3 is not on the OAuth / Coding Plan tier per
platform docs as of this PR; the highspeed
variant was the 2x-cost regression from #4082
that PR #6082 collapsed to plain M2.7 for
minimax / minimax-cn but missed OAuth)
* agent/auxiliary_client.py: drop the three legacy
_API_KEY_PROVIDER_AUX_MODELS_FALLBACK entries for the minimax
family. _get_aux_model_for_provider() reads from
ProviderProfile.default_aux_model first (line 250) and only
falls back to the dict when the profile has no aux model or
the profile import fails. With the profile now set, the dict
entries are dead code and a drift hazard. Mirrors the deepseek
cleanup in 773a0faca.
* tests/agent/test_minimax_provider.py: update the existing
TestMinimaxAuxModel assertions from MiniMax-M2.7 to MiniMax-M3
(the intent — 'standard, not highspeed' — is unchanged; the
pin value is).
* tests/plugins/model_providers/test_minimax_profile.py: new
file mirroring tests/plugins/model_providers/test_deepseek_profile.py.
Pins each of the three profiles' default_aux_model and
asserts _get_aux_model_for_provider() returns it. A second
class guards against the highspeed regression coming back.
Refs:
- Closes #36196 in spirit (M3 support — the catalog half of
that issue is #36212; this PR covers the profile half)
- Related: #4082 (M2.7-highspeed 2x-cost), #6082 (previous
M2.7-highspeed -> M2.7 fix that missed OAuth + the
auxiliary_client.py fallback dict)
- Pattern: 773a0faca (same profile-layer fix for deepseek)
450 lines
20 KiB
Python
450 lines
20 KiB
Python
"""Tests for MiniMax provider hardening — context lengths, thinking, catalog, beta headers, transport."""
|
|
|
|
from unittest.mock import patch
|
|
|
|
|
|
class TestMinimaxContextLengths:
|
|
"""Verify context length entries match official docs.
|
|
|
|
M2.x series is 204,800; M3 is 1M (max output 512K).
|
|
Source: https://platform.minimax.io/docs/api-reference/text-anthropic-api
|
|
"""
|
|
|
|
def test_minimax_prefix_has_correct_context(self):
|
|
from agent.model_metadata import DEFAULT_CONTEXT_LENGTHS
|
|
assert DEFAULT_CONTEXT_LENGTHS["minimax"] == 204_800
|
|
|
|
def test_minimax_models_resolve_via_prefix(self):
|
|
from agent.model_metadata import get_model_context_length
|
|
# M2.x models resolve to 204,800 via the "minimax" catch-all
|
|
for model in ("MiniMax-M2.7", "MiniMax-M2.5", "MiniMax-M2.1", "MiniMax-M2"):
|
|
ctx = get_model_context_length(model, "")
|
|
assert ctx == 204_800, f"{model} expected 204800, got {ctx}"
|
|
|
|
def test_minimax_m3_resolves_to_1m(self):
|
|
from agent.model_metadata import get_model_context_length
|
|
# M3 must beat the generic "minimax" catch-all (204,800) and resolve to
|
|
# a 1M-class context. The exact value depends on the source: our
|
|
# hardcoded catalog says 1,000,000; the OpenRouter catalog reports
|
|
# 1,048,576 (1024²). Either is correct — assert "≥ 1M, not 204,800".
|
|
for model in ("MiniMax-M3", "minimax/minimax-m3", "minimax-m3"):
|
|
ctx = get_model_context_length(model, "")
|
|
assert ctx >= 1_000_000, f"{model} expected 1M-class, got {ctx}"
|
|
|
|
|
|
class TestMinimaxM3StaleCacheGuard:
|
|
"""Pre-catalog builds resolved M3 via the generic 'minimax' catch-all
|
|
(204,800) and persisted it before the 'minimax-m3' (1M) catalog entry
|
|
existed. The step-1 cache guard must drop that stale value and re-resolve
|
|
to 1M, while leaving correct M2.x entries (204,800) untouched.
|
|
"""
|
|
|
|
def test_suggests_minimax_m3(self):
|
|
from agent.model_metadata import _model_name_suggests_minimax_m3
|
|
assert _model_name_suggests_minimax_m3("MiniMax-M3")
|
|
assert _model_name_suggests_minimax_m3("minimax/minimax-m3")
|
|
assert not _model_name_suggests_minimax_m3("MiniMax-M2.7")
|
|
assert not _model_name_suggests_minimax_m3("MiniMax-M2.5")
|
|
|
|
def test_stale_m3_cache_dropped_and_reresolves(self, tmp_path, monkeypatch):
|
|
monkeypatch.setenv("HERMES_HOME", str(tmp_path))
|
|
import importlib
|
|
import agent.model_metadata as mm
|
|
importlib.reload(mm)
|
|
base = "https://api.minimaxi.com/anthropic"
|
|
mm.save_context_length("MiniMax-M3", base, 204_800)
|
|
ctx = mm.get_model_context_length(
|
|
"MiniMax-M3", base_url=base, api_key="", provider="minimax-cn"
|
|
)
|
|
# Invariant: the stale 204,800 catch-all value must be DROPPED and
|
|
# re-resolved to M3's real, larger context. The exact value depends on
|
|
# the resolution source (hardcoded catalog = 1,000,000; the models.dev
|
|
# registry currently reports 512,000) — both are large-context values
|
|
# well above the generic "minimax" catch-all. Assert the contract
|
|
# ("> 204,800, stale value gone"), not a brittle literal.
|
|
assert ctx > 204_800, f"stale M3 cache not dropped/re-resolved, got {ctx}"
|
|
|
|
def test_correct_m3_cache_preserved(self, tmp_path, monkeypatch):
|
|
monkeypatch.setenv("HERMES_HOME", str(tmp_path))
|
|
import importlib
|
|
import agent.model_metadata as mm
|
|
importlib.reload(mm)
|
|
base = "https://api.minimaxi.com/anthropic"
|
|
mm.save_context_length("MiniMax-M3", base, 1_000_000)
|
|
ctx = mm.get_model_context_length(
|
|
"MiniMax-M3", base_url=base, api_key="", provider="minimax-cn"
|
|
)
|
|
assert ctx == 1_000_000
|
|
|
|
def test_m2_cache_not_clobbered(self, tmp_path, monkeypatch):
|
|
monkeypatch.setenv("HERMES_HOME", str(tmp_path))
|
|
import importlib
|
|
import agent.model_metadata as mm
|
|
importlib.reload(mm)
|
|
base = "https://api.minimaxi.com/anthropic"
|
|
# 204,800 is the CORRECT value for M2.x — guard must not touch it.
|
|
for slug in ("MiniMax-M2.7", "MiniMax-M2.5", "MiniMax-M2.1"):
|
|
mm.save_context_length(slug, base, 204_800)
|
|
ctx = mm.get_model_context_length(
|
|
slug, base_url=base, api_key="", provider="minimax-cn"
|
|
)
|
|
assert ctx == 204_800, f"{slug} should stay 204800, got {ctx}"
|
|
|
|
|
|
|
|
class TestMinimaxThinkingSupport:
|
|
"""Verify that MiniMax gets manual thinking (not adaptive).
|
|
|
|
MiniMax's Anthropic-compat endpoint officially supports the thinking
|
|
parameter (https://platform.minimax.io/docs/api-reference/text-anthropic-api).
|
|
It should get manual thinking (type=enabled + budget_tokens), NOT adaptive
|
|
thinking (which is Claude 4.6-only).
|
|
"""
|
|
|
|
def test_minimax_m27_gets_manual_thinking(self):
|
|
from agent.anthropic_adapter import build_anthropic_kwargs
|
|
kwargs = build_anthropic_kwargs(
|
|
model="MiniMax-M2.7",
|
|
messages=[{"role": "user", "content": "hello"}],
|
|
tools=None,
|
|
max_tokens=4096,
|
|
reasoning_config={"enabled": True, "effort": "medium"},
|
|
)
|
|
assert "thinking" in kwargs
|
|
assert kwargs["thinking"]["type"] == "enabled"
|
|
assert "budget_tokens" in kwargs["thinking"]
|
|
# MiniMax should NOT get adaptive thinking or output_config
|
|
assert "output_config" not in kwargs
|
|
|
|
def test_minimax_m25_gets_manual_thinking(self):
|
|
from agent.anthropic_adapter import build_anthropic_kwargs
|
|
kwargs = build_anthropic_kwargs(
|
|
model="MiniMax-M2.5",
|
|
messages=[{"role": "user", "content": "hello"}],
|
|
tools=None,
|
|
max_tokens=4096,
|
|
reasoning_config={"enabled": True, "effort": "high"},
|
|
)
|
|
assert "thinking" in kwargs
|
|
assert kwargs["thinking"]["type"] == "enabled"
|
|
|
|
def test_thinking_still_works_for_claude(self):
|
|
from agent.anthropic_adapter import build_anthropic_kwargs
|
|
kwargs = build_anthropic_kwargs(
|
|
model="claude-sonnet-4-20250514",
|
|
messages=[{"role": "user", "content": "hello"}],
|
|
tools=None,
|
|
max_tokens=4096,
|
|
reasoning_config={"enabled": True, "effort": "medium"},
|
|
)
|
|
assert "thinking" in kwargs
|
|
|
|
|
|
class TestMinimaxAuxModel:
|
|
"""Verify auxiliary model is the current frontier standard (not highspeed).
|
|
|
|
As of M3's release (2026-06-01) the minimax / minimax-cn provider
|
|
profiles advertise ``MiniMax-M3`` as their ``default_aux_model`` (the
|
|
same model users see in ``_PROVIDER_MODELS["minimax"]`` and in the
|
|
user-facing ``model.default`` for a Token-Plan install). The OAuth
|
|
/ Coding Plan path sticks with M2.7 because M3 is not on that
|
|
tier — see ``test_minimax_profile.py`` for the per-provider split.
|
|
|
|
The historical concern this class guards is the #4082 / #6082
|
|
regression: the highspeed variant costs 2x with no model-quality
|
|
benefit, so we still assert that no aux choice contains the substring
|
|
``"highspeed"``.
|
|
"""
|
|
|
|
def test_minimax_aux_is_standard(self):
|
|
from agent.auxiliary_client import _get_aux_model_for_provider
|
|
assert _get_aux_model_for_provider("minimax") == "MiniMax-M3"
|
|
assert _get_aux_model_for_provider("minimax-cn") == "MiniMax-M3"
|
|
|
|
def test_minimax_aux_not_highspeed(self):
|
|
from agent.auxiliary_client import _get_aux_model_for_provider
|
|
assert "highspeed" not in _get_aux_model_for_provider("minimax")
|
|
assert "highspeed" not in _get_aux_model_for_provider("minimax-cn")
|
|
|
|
|
|
class TestMinimaxBetaHeaders:
|
|
"""MiniMax Anthropic-compat endpoints reject fine-grained-tool-streaming beta.
|
|
|
|
Verify that build_anthropic_client omits the tool-streaming beta for MiniMax
|
|
(both global and China domains) while keeping it for native Anthropic and
|
|
other third-party endpoints. Covers the fix for #6510 / #6555.
|
|
"""
|
|
|
|
_TOOL_BETA = "fine-grained-tool-streaming-2025-05-14"
|
|
_THINKING_BETA = "interleaved-thinking-2025-05-14"
|
|
|
|
# -- helper ----------------------------------------------------------
|
|
|
|
def _build_and_get_betas(self, api_key, base_url=None):
|
|
"""Build client, return the anthropic-beta header string."""
|
|
from agent.anthropic_adapter import build_anthropic_client
|
|
with patch("agent.anthropic_adapter._anthropic_sdk") as mock_sdk:
|
|
build_anthropic_client(api_key, base_url=base_url)
|
|
kwargs = mock_sdk.Anthropic.call_args[1]
|
|
headers = kwargs.get("default_headers", {})
|
|
return headers.get("anthropic-beta", "")
|
|
|
|
# -- MiniMax global --------------------------------------------------
|
|
|
|
def test_minimax_global_omits_tool_streaming(self):
|
|
betas = self._build_and_get_betas(
|
|
"mm-key-123", base_url="https://api.minimax.io/anthropic"
|
|
)
|
|
assert self._TOOL_BETA not in betas
|
|
assert self._THINKING_BETA in betas
|
|
|
|
def test_minimax_global_trailing_slash(self):
|
|
betas = self._build_and_get_betas(
|
|
"mm-key-123", base_url="https://api.minimax.io/anthropic/"
|
|
)
|
|
assert self._TOOL_BETA not in betas
|
|
|
|
# -- MiniMax China ---------------------------------------------------
|
|
|
|
def test_minimax_cn_omits_tool_streaming(self):
|
|
betas = self._build_and_get_betas(
|
|
"mm-cn-key-456", base_url="https://api.minimaxi.com/anthropic"
|
|
)
|
|
assert self._TOOL_BETA not in betas
|
|
assert self._THINKING_BETA in betas
|
|
|
|
def test_minimax_cn_trailing_slash(self):
|
|
betas = self._build_and_get_betas(
|
|
"mm-cn-key-456", base_url="https://api.minimaxi.com/anthropic/"
|
|
)
|
|
assert self._TOOL_BETA not in betas
|
|
|
|
# -- Non-MiniMax keeps full betas ------------------------------------
|
|
|
|
def test_native_anthropic_keeps_tool_streaming(self):
|
|
betas = self._build_and_get_betas("sk-ant-api03-real-key-here")
|
|
assert self._TOOL_BETA in betas
|
|
assert self._THINKING_BETA in betas
|
|
|
|
def test_third_party_proxy_keeps_tool_streaming(self):
|
|
betas = self._build_and_get_betas(
|
|
"custom-key", base_url="https://my-proxy.example.com/anthropic"
|
|
)
|
|
assert self._TOOL_BETA in betas
|
|
|
|
def test_custom_base_url_keeps_tool_streaming(self):
|
|
betas = self._build_and_get_betas(
|
|
"custom-key", base_url="https://custom.api.com"
|
|
)
|
|
assert self._TOOL_BETA in betas
|
|
|
|
# -- _common_betas_for_base_url unit tests ---------------------------
|
|
|
|
def test_common_betas_none_url(self):
|
|
from agent.anthropic_adapter import _common_betas_for_base_url, _COMMON_BETAS
|
|
assert _common_betas_for_base_url(None) == _COMMON_BETAS
|
|
|
|
def test_common_betas_empty_url(self):
|
|
from agent.anthropic_adapter import _common_betas_for_base_url, _COMMON_BETAS
|
|
assert _common_betas_for_base_url("") == _COMMON_BETAS
|
|
|
|
def test_common_betas_minimax_url(self):
|
|
from agent.anthropic_adapter import _common_betas_for_base_url, _TOOL_STREAMING_BETA
|
|
betas = _common_betas_for_base_url("https://api.minimax.io/anthropic")
|
|
assert _TOOL_STREAMING_BETA not in betas
|
|
assert len(betas) > 0 # still has other betas
|
|
|
|
def test_common_betas_minimax_cn_url(self):
|
|
from agent.anthropic_adapter import _common_betas_for_base_url, _TOOL_STREAMING_BETA
|
|
betas = _common_betas_for_base_url("https://api.minimaxi.com/anthropic")
|
|
assert _TOOL_STREAMING_BETA not in betas
|
|
|
|
def test_common_betas_regular_url(self):
|
|
from agent.anthropic_adapter import _common_betas_for_base_url, _COMMON_BETAS
|
|
assert _common_betas_for_base_url("https://api.anthropic.com") == _COMMON_BETAS
|
|
|
|
|
|
class TestMinimaxApiMode:
|
|
"""Verify determine_api_mode returns anthropic_messages for MiniMax providers.
|
|
|
|
The MiniMax /anthropic endpoint speaks Anthropic Messages wire format,
|
|
not OpenAI chat completions. The overlay transport must reflect this
|
|
so that code paths calling determine_api_mode() without a base_url
|
|
(e.g. /model switch) get the correct api_mode.
|
|
"""
|
|
|
|
def test_minimax_returns_anthropic_messages(self):
|
|
from hermes_cli.providers import determine_api_mode
|
|
assert determine_api_mode("minimax") == "anthropic_messages"
|
|
|
|
def test_minimax_cn_returns_anthropic_messages(self):
|
|
from hermes_cli.providers import determine_api_mode
|
|
assert determine_api_mode("minimax-cn") == "anthropic_messages"
|
|
|
|
def test_minimax_with_url_also_works(self):
|
|
from hermes_cli.providers import determine_api_mode
|
|
# Even with explicit base_url, provider lookup takes priority
|
|
assert determine_api_mode("minimax", "https://api.minimax.io/anthropic") == "anthropic_messages"
|
|
|
|
def test_anthropic_still_returns_anthropic_messages(self):
|
|
from hermes_cli.providers import determine_api_mode
|
|
assert determine_api_mode("anthropic") == "anthropic_messages"
|
|
|
|
def test_openai_returns_chat_completions(self):
|
|
from hermes_cli.providers import determine_api_mode
|
|
# Sanity check: standard providers are unaffected
|
|
result = determine_api_mode("deepseek")
|
|
assert result == "chat_completions"
|
|
|
|
|
|
class TestMinimaxMaxOutput:
|
|
"""Verify _get_anthropic_max_output returns correct limits for MiniMax models.
|
|
|
|
MiniMax max output is 131,072 tokens (source: OpenClaw model definitions,
|
|
cross-referenced with MiniMax API behavior).
|
|
"""
|
|
|
|
def test_minimax_m27_output_limit(self):
|
|
from agent.anthropic_adapter import _get_anthropic_max_output
|
|
assert _get_anthropic_max_output("MiniMax-M2.7") == 131_072
|
|
|
|
def test_minimax_m25_output_limit(self):
|
|
from agent.anthropic_adapter import _get_anthropic_max_output
|
|
assert _get_anthropic_max_output("MiniMax-M2.5") == 131_072
|
|
|
|
def test_minimax_m2_output_limit(self):
|
|
from agent.anthropic_adapter import _get_anthropic_max_output
|
|
assert _get_anthropic_max_output("MiniMax-M2") == 131_072
|
|
|
|
def test_claude_output_unaffected(self):
|
|
from agent.anthropic_adapter import _get_anthropic_max_output
|
|
# Sanity: Claude limits are not broken by the MiniMax entry
|
|
assert _get_anthropic_max_output("claude-sonnet-4-6") == 64_000
|
|
|
|
|
|
class TestMinimaxPreserveDots:
|
|
"""Verify that MiniMax model names preserve dots through the Anthropic adapter.
|
|
|
|
MiniMax model IDs like 'MiniMax-M2.7' must NOT have dots converted to
|
|
hyphens — the endpoint expects the exact name with dots.
|
|
"""
|
|
|
|
def test_minimax_provider_preserves_dots(self):
|
|
from types import SimpleNamespace
|
|
agent = SimpleNamespace(provider="minimax", base_url="")
|
|
from run_agent import AIAgent
|
|
assert AIAgent._anthropic_preserve_dots(agent) is True
|
|
|
|
def test_minimax_cn_provider_preserves_dots(self):
|
|
from types import SimpleNamespace
|
|
agent = SimpleNamespace(provider="minimax-cn", base_url="")
|
|
from run_agent import AIAgent
|
|
assert AIAgent._anthropic_preserve_dots(agent) is True
|
|
|
|
def test_minimax_url_preserves_dots(self):
|
|
from types import SimpleNamespace
|
|
agent = SimpleNamespace(provider="custom", base_url="https://api.minimax.io/anthropic")
|
|
from run_agent import AIAgent
|
|
assert AIAgent._anthropic_preserve_dots(agent) is True
|
|
|
|
def test_minimax_cn_url_preserves_dots(self):
|
|
from types import SimpleNamespace
|
|
agent = SimpleNamespace(provider="custom", base_url="https://api.minimaxi.com/anthropic")
|
|
from run_agent import AIAgent
|
|
assert AIAgent._anthropic_preserve_dots(agent) is True
|
|
|
|
def test_anthropic_does_not_preserve_dots(self):
|
|
from types import SimpleNamespace
|
|
agent = SimpleNamespace(provider="anthropic", base_url="https://api.anthropic.com")
|
|
from run_agent import AIAgent
|
|
assert AIAgent._anthropic_preserve_dots(agent) is False
|
|
|
|
def test_opencode_zen_provider_preserves_dots(self):
|
|
from types import SimpleNamespace
|
|
agent = SimpleNamespace(provider="opencode-zen", base_url="")
|
|
from run_agent import AIAgent
|
|
assert AIAgent._anthropic_preserve_dots(agent) is True
|
|
|
|
def test_opencode_zen_url_preserves_dots(self):
|
|
from types import SimpleNamespace
|
|
agent = SimpleNamespace(provider="custom", base_url="https://opencode.ai/zen/v1")
|
|
from run_agent import AIAgent
|
|
assert AIAgent._anthropic_preserve_dots(agent) is True
|
|
|
|
def test_zai_provider_preserves_dots(self):
|
|
from types import SimpleNamespace
|
|
agent = SimpleNamespace(provider="zai", base_url="")
|
|
from run_agent import AIAgent
|
|
assert AIAgent._anthropic_preserve_dots(agent) is True
|
|
|
|
def test_bigmodel_cn_url_preserves_dots(self):
|
|
from types import SimpleNamespace
|
|
agent = SimpleNamespace(provider="custom", base_url="https://open.bigmodel.cn/api/paas/v4")
|
|
from run_agent import AIAgent
|
|
assert AIAgent._anthropic_preserve_dots(agent) is True
|
|
|
|
def test_normalize_preserves_m25_free_dot(self):
|
|
from agent.anthropic_adapter import normalize_model_name
|
|
assert normalize_model_name("minimax-m2.5-free", preserve_dots=True) == "minimax-m2.5-free"
|
|
|
|
def test_normalize_preserves_m27_dot(self):
|
|
from agent.anthropic_adapter import normalize_model_name
|
|
assert normalize_model_name("MiniMax-M2.7", preserve_dots=True) == "MiniMax-M2.7"
|
|
|
|
def test_normalize_preserves_non_anthropic_dots_without_preserve(self):
|
|
from agent.anthropic_adapter import normalize_model_name
|
|
# Non-Anthropic model families use dots as canonical version separators;
|
|
# only Claude/Anthropic names are hyphen-normalized by default.
|
|
assert normalize_model_name("MiniMax-M2.7", preserve_dots=False) == "MiniMax-M2.7"
|
|
|
|
def test_normalize_still_converts_claude_dots_without_preserve(self):
|
|
from agent.anthropic_adapter import normalize_model_name
|
|
assert normalize_model_name("claude-opus-4.6", preserve_dots=False) == "claude-opus-4-6"
|
|
|
|
|
|
class TestMinimaxSwitchModelCredentialGuard:
|
|
"""Verify switch_model() does not leak Anthropic credentials to MiniMax.
|
|
|
|
The __init__ path correctly guards against this (line 761), but switch_model()
|
|
must mirror that guard. Without it, /model switch to minimax with no explicit
|
|
api_key would fall back to resolve_anthropic_token() and send Anthropic creds
|
|
to the MiniMax endpoint.
|
|
"""
|
|
|
|
def test_switch_to_minimax_does_not_resolve_anthropic_token(self):
|
|
"""switch_model() should NOT call resolve_anthropic_token() for MiniMax."""
|
|
from unittest.mock import patch, MagicMock
|
|
|
|
with patch("run_agent.AIAgent.__init__", return_value=None):
|
|
from run_agent import AIAgent
|
|
agent = AIAgent.__new__(AIAgent)
|
|
agent.provider = "anthropic"
|
|
agent.model = "claude-sonnet-4"
|
|
agent.api_key = "sk-ant-fake"
|
|
agent.base_url = "https://api.anthropic.com"
|
|
agent.api_mode = "anthropic_messages"
|
|
agent._anthropic_base_url = "https://api.anthropic.com"
|
|
agent._anthropic_api_key = "sk-ant-fake"
|
|
agent._is_anthropic_oauth = False
|
|
agent._client_kwargs = {}
|
|
agent.client = None
|
|
agent._anthropic_client = MagicMock()
|
|
agent._fallback_chain = []
|
|
|
|
with patch("agent.anthropic_adapter.build_anthropic_client") as mock_build, \
|
|
patch("agent.anthropic_adapter.resolve_anthropic_token", return_value="sk-ant-leaked") as mock_resolve, \
|
|
patch("agent.anthropic_adapter._is_oauth_token", return_value=False):
|
|
|
|
agent.switch_model(
|
|
new_model="MiniMax-M2.7",
|
|
new_provider="minimax",
|
|
api_mode="anthropic_messages",
|
|
api_key="mm-key-123",
|
|
base_url="https://api.minimax.io/anthropic",
|
|
)
|
|
# resolve_anthropic_token should NOT be called for non-Anthropic providers
|
|
mock_resolve.assert_not_called()
|
|
# The key passed to build_anthropic_client should be the MiniMax key
|
|
build_args = mock_build.call_args
|
|
assert build_args[0][0] == "mm-key-123"
|