fix(config): make model preset switching atomic

Co-authored-by: Cursor <cursoragent@cursor.com>

tests/agent/test_self_model_preset.py

@@ -7,6 +7,7 @@ from nanobot.agent.loop import AgentLoop
 from nanobot.agent.tools.self import MyTool
 from nanobot.bus.queue import MessageBus
 from nanobot.config.schema import ModelPresetConfig
+from nanobot.providers.factory import ProviderSnapshot
 
 
 def _provider(default_model: str, max_tokens: int = 123) -> MagicMock:
@@ -56,6 +57,75 @@ def test_model_preset_setter_updates_state(tmp_path) -> None:
     assert loop.provider.generation.temperature == 0.5
     assert loop.provider.generation.max_tokens == 4096
     assert loop.provider.generation.reasoning_effort == "low"
+    assert loop.subagents.model == "openai/gpt-4.1"
+    assert loop.consolidator.model == "openai/gpt-4.1"
+    assert loop.consolidator.context_window_tokens == 32_768
+    assert loop.consolidator.max_completion_tokens == 4096
+    assert loop.dream.model == "openai/gpt-4.1"
+
+
+def test_model_preset_setter_replaces_provider_from_snapshot(tmp_path) -> None:
+    old_provider = _provider("base-model", max_tokens=123)
+    new_provider = _provider("anthropic/claude-opus-4-5", max_tokens=2048)
+    preset = ModelPresetConfig(
+        model="anthropic/claude-opus-4-5",
+        provider="anthropic",
+        max_tokens=2048,
+        context_window_tokens=200_000,
+    )
+    loop = AgentLoop(
+        bus=MessageBus(),
+        provider=old_provider,
+        workspace=tmp_path,
+        model="base-model",
+        context_window_tokens=1000,
+        model_presets={"deep": preset},
+        model_preset_snapshot_builder=lambda _preset: ProviderSnapshot(
+            provider=new_provider,
+            model=_preset.model,
+            context_window_tokens=_preset.context_window_tokens,
+            signature=("deep", _preset.model),
+        ),
+    )
+
+    loop.set_model_preset("deep")
+
+    assert loop.provider is new_provider
+    assert loop.runner.provider is new_provider
+    assert loop.subagents.provider is new_provider
+    assert loop.subagents.runner.provider is new_provider
+    assert loop.consolidator.provider is new_provider
+    assert loop.dream.provider is new_provider
+    assert loop.dream._runner.provider is new_provider
+    assert loop.model == "anthropic/claude-opus-4-5"
+    assert loop.context_window_tokens == 200_000
+    assert loop.consolidator.max_completion_tokens == 2048
+
+
+def test_model_preset_setter_failure_leaves_old_state(tmp_path) -> None:
+    preset = ModelPresetConfig(model="openai/gpt-4.1", max_tokens=4096)
+    loop = AgentLoop(
+        bus=MessageBus(),
+        provider=_provider("base-model", max_tokens=123),
+        workspace=tmp_path,
+        model="base-model",
+        context_window_tokens=1000,
+        model_presets={"fast": preset},
+        model_preset_snapshot_builder=lambda _preset: (_ for _ in ()).throw(
+            RuntimeError("provider unavailable")
+        ),
+    )
+
+    with pytest.raises(RuntimeError, match="provider unavailable"):
+        loop.set_model_preset("fast")
+
+    assert loop.model_preset is None
+    assert loop.model == "base-model"
+    assert loop.subagents.model == "base-model"
+    assert loop.consolidator.model == "base-model"
+    assert loop.dream.model == "base-model"
+    assert loop.context_window_tokens == 1000
+    assert loop.consolidator.max_completion_tokens == 123
 
 
 def test_model_preset_setter_raises_on_unknown(tmp_path) -> None:

tests/command/test_model_command.py

@@ -0,0 +1,137 @@
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import pytest
+
+from nanobot.agent.loop import AgentLoop
+from nanobot.bus.events import InboundMessage
+from nanobot.bus.queue import MessageBus
+from nanobot.command.builtin import (
+    build_help_text,
+    builtin_command_palette,
+    cmd_model,
+    register_builtin_commands,
+)
+from nanobot.command.router import CommandContext, CommandRouter
+from nanobot.config.schema import ModelPresetConfig
+
+
+def _provider(default_model: str, max_tokens: int = 123) -> MagicMock:
+    provider = MagicMock()
+    provider.get_default_model.return_value = default_model
+    provider.generation = SimpleNamespace(
+        max_tokens=max_tokens,
+        temperature=0.1,
+        reasoning_effort=None,
+    )
+    return provider
+
+
+def _make_loop(tmp_path) -> AgentLoop:
+    return AgentLoop(
+        bus=MessageBus(),
+        provider=_provider("base-model", max_tokens=123),
+        workspace=tmp_path,
+        model="base-model",
+        context_window_tokens=1000,
+        model_presets={
+            "default": ModelPresetConfig(
+                model="base-model",
+                max_tokens=123,
+                context_window_tokens=1000,
+            ),
+            "fast": ModelPresetConfig(
+                model="openai/gpt-4.1",
+                max_tokens=4096,
+                context_window_tokens=32_768,
+            ),
+        },
+    )
+
+
+def _ctx(loop: AgentLoop, raw: str, args: str = "") -> CommandContext:
+    msg = InboundMessage(channel="cli", sender_id="user", chat_id="direct", content=raw)
+    return CommandContext(msg=msg, session=None, key=msg.session_key, raw=raw, args=args, loop=loop)
+
+
+@pytest.mark.asyncio
+async def test_model_command_lists_current_and_available_presets(tmp_path) -> None:
+    loop = _make_loop(tmp_path)
+
+    out = await cmd_model(_ctx(loop, "/model"))
+
+    assert "Current model: `base-model`" in out.content
+    assert "Active preset: `(none)`" in out.content
+    assert "`default`" in out.content
+    assert "`fast`" in out.content
+    assert out.metadata == {"render_as": "text"}
+
+
+@pytest.mark.asyncio
+async def test_model_command_switches_preset(tmp_path) -> None:
+    loop = _make_loop(tmp_path)
+
+    out = await cmd_model(_ctx(loop, "/model fast", args="fast"))
+
+    assert "Switched model preset to `fast`." in out.content
+    assert "Model: `openai/gpt-4.1`" in out.content
+    assert loop.model_preset == "fast"
+    assert loop.model == "openai/gpt-4.1"
+    assert loop.subagents.model == "openai/gpt-4.1"
+    assert loop.consolidator.model == "openai/gpt-4.1"
+    assert loop.dream.model == "openai/gpt-4.1"
+
+
+@pytest.mark.asyncio
+async def test_model_command_switches_back_to_default(tmp_path) -> None:
+    loop = _make_loop(tmp_path)
+    loop.set_model_preset("fast")
+
+    out = await cmd_model(_ctx(loop, "/model default", args="default"))
+
+    assert "Switched model preset to `default`." in out.content
+    assert loop.model_preset == "default"
+    assert loop.model == "base-model"
+    assert loop.context_window_tokens == 1000
+
+
+@pytest.mark.asyncio
+async def test_model_command_unknown_preset_keeps_old_state(tmp_path) -> None:
+    loop = _make_loop(tmp_path)
+
+    out = await cmd_model(_ctx(loop, "/model missing", args="missing"))
+
+    assert "Could not switch model preset" in out.content
+    assert "Available presets: `default`, `fast`" in out.content
+    assert loop.model_preset is None
+    assert loop.model == "base-model"
+
+
+@pytest.mark.asyncio
+async def test_model_command_does_not_depend_on_my_allow_set(tmp_path) -> None:
+    loop = _make_loop(tmp_path)
+    assert loop.tools_config.my.allow_set is False
+
+    await cmd_model(_ctx(loop, "/model fast", args="fast"))
+
+    assert loop.model_preset == "fast"
+
+
+@pytest.mark.asyncio
+async def test_model_command_registered_as_exact_and_prefix(tmp_path) -> None:
+    router = CommandRouter()
+    register_builtin_commands(router)
+    loop = _make_loop(tmp_path)
+
+    out = await router.dispatch(_ctx(loop, "/model fast"))
+
+    assert out is not None
+    assert "Switched model preset" in out.content
+    assert loop.model_preset == "fast"
+
+
+def test_model_command_in_help_and_palette() -> None:
+    palette = builtin_command_palette()
+
+    assert any(item["command"] == "/model" and item["arg_hint"] == "[preset]" for item in palette)
+    assert "/model [preset]" in build_help_text()

tests/command/test_router_dispatchable.py

@@ -22,6 +22,7 @@ class TestIsDispatchableCommand:
     def test_exact_commands_match(self, router: CommandRouter) -> None:
         assert router.is_dispatchable_command("/new")
         assert router.is_dispatchable_command("/help")
+        assert router.is_dispatchable_command("/model")
         assert router.is_dispatchable_command("/dream")
         assert router.is_dispatchable_command("/dream-log")
         assert router.is_dispatchable_command("/dream-restore")
@@ -29,6 +30,7 @@ class TestIsDispatchableCommand:
     def test_prefix_commands_match(self, router: CommandRouter) -> None:
         assert router.is_dispatchable_command("/dream-log abc123")
         assert router.is_dispatchable_command("/dream-restore def456")
+        assert router.is_dispatchable_command("/model fast")
 
     def test_priority_commands_not_matched(self, router: CommandRouter) -> None:
         # Priority commands are NOT in the dispatchable tiers — they are

tests/config/test_model_presets.py

@@ -1,4 +1,4 @@
-from nanobot.config.schema import Config, ModelPresetConfig
+from nanobot.config.schema import Config
 
 
 def test_resolve_preset_returns_defaults_when_no_preset() -> None:
@@ -39,6 +39,20 @@ def test_resolve_preset_returns_active_preset() -> None:
     assert resolved.reasoning_effort == "low"
 
 
+def test_resolve_preset_can_target_named_preset_without_activating() -> None:
+    config = Config.model_validate({
+        "model_presets": {
+            "fast": {"model": "openai/gpt-4.1", "provider": "openai"},
+            "deep": {"model": "anthropic/claude-opus-4-5", "provider": "anthropic"},
+        },
+        "agents": {"defaults": {"modelPreset": "fast"}},
+    })
+
+    resolved = config.resolve_preset("deep")
+    assert resolved.model == "anthropic/claude-opus-4-5"
+    assert resolved.provider == "anthropic"
+
+
 def test_validator_rejects_unknown_preset() -> None:
     import pytest
     with pytest.raises(ValueError, match="model_preset 'unknown' not found in model_presets"):
@@ -51,6 +65,12 @@ def test_validator_rejects_unknown_preset() -> None:
         })
 
 
+def test_resolve_preset_rejects_unknown_named_preset() -> None:
+    import pytest
+    with pytest.raises(KeyError, match="model_preset 'missing' not found"):
+        Config().resolve_preset("missing")
+
+
 def test_match_provider_uses_preset_model() -> None:
     config = Config.model_validate({
         "providers": {