初始化提交

backend/tests/ai_provider/routing/test_multimodal.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+from app.ai_provider.routing.multimodal import MultiModalDecision, MultiModalRouter
+
+
+class TestMultiModalDecision:
+    def test_enum_values(self):
+        assert MultiModalDecision.PLAIN_TEXT == "plain_text"
+        assert MultiModalDecision.VISION == "vision"
+        assert MultiModalDecision.THINKING == "thinking"
+        assert MultiModalDecision.TOOL_USE == "tool_use"
+        assert MultiModalDecision.STRUCTURED_OUTPUT == "structured_output"
+
+    def test_enum_is_str_enum(self):
+        assert issubclass(MultiModalDecision, str)
+
+
+class TestMultiModalRouter:
+    def test_plain_text_message(self):
+        messages = [{"role": "user", "content": "Hello, world!"}]
+        decisions = MultiModalRouter.decide_from_messages(messages)
+        assert decisions == {MultiModalDecision.PLAIN_TEXT}
+
+    def test_plain_text_multiple_messages(self):
+        messages = [
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": "What is Python?"},
+            {"role": "assistant", "content": "Python is a programming language."},
+        ]
+        decisions = MultiModalRouter.decide_from_messages(messages)
+        assert decisions == {MultiModalDecision.PLAIN_TEXT}
+
+    def test_vision_with_openai_image_url_block(self):
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": "What's in this image?"},
+                    {"type": "image_url", "image_url": {"url": "https://example.com/img.png"}},
+                ],
+            }
+        ]
+        decisions = MultiModalRouter.decide_from_messages(messages)
+        assert MultiModalDecision.VISION in decisions
+
+    def test_vision_with_image_type_block(self):
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": "Describe this"},
+                    {
+                        "type": "image",
+                        "source": {"type": "base64", "media_type": "image/png", "data": "..."},
+                    },
+                ],
+            }
+        ]
+        decisions = MultiModalRouter.decide_from_messages(messages)
+        assert MultiModalDecision.VISION in decisions
+
+    def test_plain_text_with_single_content_block(self):
+        """A single text-only content block should not trigger VISION."""
+        messages = [
+            {
+                "role": "user",
+                "content": [{"type": "text", "text": "Hello!"}],
+            }
+        ]
+        decisions = MultiModalRouter.decide_from_messages(messages)
+        assert MultiModalDecision.VISION not in decisions
+
+    def test_tool_use_from_assistant_tool_calls(self):
+        messages = [
+            {"role": "user", "content": "What's the weather?"},
+            {
+                "role": "assistant",
+                "content": "",
+                "tool_calls": [
+                    {"id": "call_1", "function": {"name": "get_weather", "arguments": "{}"}}
+                ],
+            },
+        ]
+        decisions = MultiModalRouter.decide_from_messages(messages)
+        assert MultiModalDecision.TOOL_USE in decisions
+
+    def test_tool_use_from_tool_role(self):
+        messages = [
+            {"role": "user", "content": "What's the weather?"},
+            {
+                "role": "assistant",
+                "content": "",
+                "tool_calls": [{"id": "call_1", "name": "get_weather"}],
+            },
+            {"role": "tool", "content": "25°C", "tool_call_id": "call_1"},
+        ]
+        decisions = MultiModalRouter.decide_from_messages(messages)
+        assert MultiModalDecision.TOOL_USE in decisions
+
+    def test_thinking_from_reasoning_field(self):
+        messages = [
+            {"role": "user", "content": "Think step by step"},
+            {"role": "assistant", "content": "Final answer", "reasoning": "Let me think..."},
+        ]
+        decisions = MultiModalRouter.decide_from_messages(messages)
+        assert MultiModalDecision.THINKING in decisions
+
+    def test_empty_messages(self):
+        decisions = MultiModalRouter.decide_from_messages([])
+        assert decisions == {MultiModalDecision.PLAIN_TEXT}
+
+    def test_multiple_capabilities_combined(self):
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": "Analyze this image step by step"},
+                    {"type": "image_url", "image_url": {"url": "https://example.com/img.png"}},
+                ],
+            },
+            {
+                "role": "assistant",
+                "content": "Let me think about this image...",
+                "reasoning": "First, I see an image. Let me analyze it carefully.",
+                "tool_calls": [
+                    {"id": "call_1", "function": {"name": "analyze_image", "arguments": "{}"}}
+                ],
+            },
+            {"role": "tool", "content": "Analysis complete", "tool_call_id": "call_1"},
+        ]
+        decisions = MultiModalRouter.decide_from_messages(messages)
+        assert MultiModalDecision.VISION in decisions
+        assert MultiModalDecision.THINKING in decisions
+        assert MultiModalDecision.TOOL_USE in decisions
+
+    def test_decide_with_empty_content(self):
+        messages = [{"role": "user", "content": ""}]
+        decisions = MultiModalRouter.decide_from_messages(messages)
+        assert decisions == {MultiModalDecision.PLAIN_TEXT}

backend/tests/ai_provider/routing/test_permissions.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+from app.ai_provider.routing.permissions import CapabilityPermissionController, PermissionRule
+
+
+class TestPermissionRule:
+    def test_exact_match(self):
+        rule = PermissionRule(model_pattern="fast-model", capability="vision", allowed=True)
+        assert rule.match("fast-model") is True
+        assert rule.match("pro-model") is False
+
+    def test_wildcard_match(self):
+        rule = PermissionRule(model_pattern="deepseek-*", capability="thinking", allowed=False)
+        assert rule.match("deepseek-v4-flash") is True
+        assert rule.match("deepseek-v4-pro") is True
+        assert rule.match("claude-sonnet-4-6") is False
+
+    def test_universal_match(self):
+        rule = PermissionRule(model_pattern="*", capability="vision", allowed=True)
+        assert rule.match("any-model") is True
+        assert rule.match("another-one") is True
+
+    def test_suffix_wildcard(self):
+        rule = PermissionRule(model_pattern="*-pro", capability="thinking", allowed=True)
+        assert rule.match("deepseek-v4-pro") is True
+        assert rule.match("fast-model") is False
+
+    def test_match_method_called_explicitly(self):
+        rule = PermissionRule(model_pattern="vision-*", capability="vision")
+        assert rule.match("vision-model") is True
+
+    def test_allowed_defaults_to_true(self):
+        rule = PermissionRule(model_pattern="*", capability="vision")
+        assert rule.allowed is True
+
+    def test_allowed_set_to_false(self):
+        rule = PermissionRule(model_pattern="*", capability="vision", allowed=False)
+        assert rule.allowed is False
+
+    def test_repr(self):
+        rule = PermissionRule(model_pattern="*", capability="vision", allowed=True)
+        r = repr(rule)
+        assert "PermissionRule" in r
+        assert "*" in r
+        assert "vision" in r
+
+    def test_eq_same_rules(self):
+        rule1 = PermissionRule(model_pattern="foo-*", capability="vision", allowed=True)
+        rule2 = PermissionRule(model_pattern="foo-*", capability="vision", allowed=True)
+        assert rule1 == rule2
+
+    def test_eq_different_rules(self):
+        rule1 = PermissionRule(model_pattern="foo-*", capability="vision", allowed=True)
+        rule2 = PermissionRule(model_pattern="bar-*", capability="vision", allowed=True)
+        assert rule1 != rule2
+
+
+class TestCapabilityPermissionController:
+    def test_allow_all_by_default(self):
+        controller = CapabilityPermissionController([])
+        assert controller.check("fast-model", "vision") is True
+
+    def test_deny_specific_capability_on_model(self):
+        controller = CapabilityPermissionController(
+            [
+                PermissionRule(model_pattern="fast-*", capability="vision", allowed=False),
+            ]
+        )
+        assert controller.check("fast-model", "vision") is False
+        assert controller.check("pro-model", "vision") is True
+
+    def test_deny_then_allow_more_specific(self):
+        """A more specific deny should override a broader allow."""
+        controller = CapabilityPermissionController(
+            [
+                PermissionRule(model_pattern="*", capability="thinking", allowed=True),
+                PermissionRule(model_pattern="fast-*", capability="thinking", allowed=False),
+            ]
+        )
+        assert controller.check("fast-model", "thinking") is False
+        assert controller.check("pro-model", "thinking") is True
+
+    def test_filter_capabilities(self):
+        controller = CapabilityPermissionController(
+            [
+                PermissionRule(model_pattern="*", capability="vision", allowed=False),
+                PermissionRule(model_pattern="vision-*", capability="vision", allowed=True),
+            ]
+        )
+        filtered = controller.filter_capabilities("fast-model", {"chat", "vision", "thinking"})
+        assert filtered == {"chat", "thinking"}
+
+        filtered_vision = controller.filter_capabilities(
+            "vision-model", {"chat", "vision", "thinking"}
+        )
+        assert filtered_vision == {"chat", "vision", "thinking"}
+
+    def test_filter_with_no_rules(self):
+        controller = CapabilityPermissionController([])
+        filtered = controller.filter_capabilities("any-model", {"chat", "vision"})
+        assert filtered == {"chat", "vision"}
+
+    def test_check_nonexistent_model(self):
+        """Non-existent models should still be checked against rules."""
+        controller = CapabilityPermissionController(
+            [
+                PermissionRule(model_pattern="*", capability="vision", allowed=False),
+            ]
+        )
+        assert controller.check("unknown-model", "vision") is False
+
+    def test_multiple_rules_matching(self):
+        """When multiple rules match, the last one wins (most specific wins by order)."""
+        controller = CapabilityPermissionController(
+            [
+                PermissionRule(model_pattern="*", capability="tool_use", allowed=True),
+                PermissionRule(model_pattern="basic-*", capability="tool_use", allowed=False),
+                PermissionRule(model_pattern="basic-pro", capability="tool_use", allowed=True),
+            ]
+        )
+        assert controller.check("basic-lite", "tool_use") is False
+        assert controller.check("basic-pro", "tool_use") is True
+        assert controller.check("pro-model", "tool_use") is True
+
+    def test_check_capability_not_in_rules(self):
+        controller = CapabilityPermissionController(
+            [
+                PermissionRule(model_pattern="*", capability="vision", allowed=False),
+            ]
+        )
+        # 'chat' is not in any rule, so it's allowed by default
+        assert controller.check("fast-model", "chat") is True
+
+    def test_is_allowed_model(self):
+        controller = CapabilityPermissionController(
+            [
+                PermissionRule(model_pattern="*", capability="vision", allowed=False),
+            ]
+        )
+        assert controller.is_allowed("fast-model", "vision") is False
+        assert controller.is_allowed("fast-model", "chat") is True

backend/tests/ai_provider/routing/test_selector.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import pytest
+
+from app.ai_provider.config.models import ModelConfig
+from app.ai_provider.core.registry import ModelRegistry
+from app.ai_provider.routing.multimodal import MultiModalDecision
+from app.ai_provider.routing.selector import ModelSelector
+from app.ai_provider.types.errors import AIProviderError
+
+
+class TestModelSelector:
+    @pytest.fixture
+    def registry(self):
+        models = [
+            ModelConfig(
+                name="fast-model",
+                provider="deepseek",
+                model="deepseek-v4-flash",
+                format="openai",
+                tags=["default"],
+                weight=100,
+            ),
+            ModelConfig(
+                name="pro-model",
+                provider="deepseek",
+                model="deepseek-v4-pro",
+                format="openai",
+                tags=["fallback"],
+                weight=50,
+            ),
+            ModelConfig(
+                name="vision-model",
+                provider="anthropic",
+                model="claude-sonnet-4-6",
+                format="anthropic",
+                supports_vision=True,
+                supports_thinking=True,
+                supports_tools=True,
+            ),
+            ModelConfig(
+                name="thinking-model",
+                provider="deepseek",
+                model="deepseek-v4-thinking",
+                format="openai",
+                supports_reasoning_effort=True,
+                supports_thinking=True,
+            ),
+        ]
+        return ModelRegistry(models)
+
+    def test_select_default_model(self, registry):
+        selector = ModelSelector(registry)
+        model = selector.select({})
+        assert model.name == "fast-model"
+
+    def test_select_with_preferred_model(self, registry):
+        selector = ModelSelector(registry)
+        model = selector.select({"preferred": "pro-model"})
+        assert model.name == "pro-model"
+
+    def test_select_preferred_with_capability(self, registry):
+        selector = ModelSelector(registry)
+        model = selector.select({"preferred": "vision-model", "capabilities": {"vision"}})
+        assert model.name == "vision-model"
+
+    def test_select_preferred_missing_required_capability(self, registry):
+        """Preferred model doesn't have required capability — falls back."""
+        selector = ModelSelector(registry)
+        model = selector.select({"preferred": "fast-model", "capabilities": {"vision"}})
+        assert model.name != "fast-model"
+        assert "vision" in model.resolved_capabilities()
+        assert model.resolved_capabilities()["vision"] is True
+
+    def test_select_for_vision(self, registry):
+        selector = ModelSelector(registry)
+        model = selector.select({"capabilities": {"vision"}})
+        assert model.name == "vision-model"
+
+    def test_select_for_thinking(self, registry):
+        selector = ModelSelector(registry)
+        model = selector.select({"capabilities": {"thinking"}})
+        assert model.resolved_capabilities()["thinking"] is True
+
+    def test_select_for_tool_use(self, registry):
+        selector = ModelSelector(registry)
+        model = selector.select({"capabilities": {"tool_use"}})
+        assert model.resolved_capabilities()["tool_use"] is True
+
+    def test_select_for_multiple_capabilities(self, registry):
+        selector = ModelSelector(registry)
+        model = selector.select({"capabilities": {"vision", "thinking"}})
+        assert model.resolved_capabilities()["vision"] is True
+        assert model.resolved_capabilities()["thinking"] is True
+
+    def test_select_from_multi_modal_decision(self, registry):
+        selector = ModelSelector(registry)
+        model = selector.select_from_decisions(
+            {MultiModalDecision.VISION, MultiModalDecision.THINKING}
+        )
+        assert model.resolved_capabilities()["vision"] is True
+        assert model.resolved_capabilities()["thinking"] is True
+
+    def test_select_from_plain_text_decision(self, registry):
+        selector = ModelSelector(registry)
+        model = selector.select_from_decisions({MultiModalDecision.PLAIN_TEXT})
+        assert model.name == "fast-model"
+
+    def test_select_with_invalid_preferred(self, registry):
+        selector = ModelSelector(registry)
+        with pytest.raises(AIProviderError):
+            selector.select({"preferred": "nonexistent-model"})
+
+    def test_select_with_capability_no_match(self, registry):
+        """No model supports an unknown capability."""
+        selector = ModelSelector(registry)
+        with pytest.raises(AIProviderError):
+            selector.select({"capabilities": {"telepathy"}})
+
+    def test_select_allows_preferred_with_superset_capabilities(self, registry):
+        """Preferred model has MORE capabilities than required — should still match."""
+        selector = ModelSelector(registry)
+        model = selector.select({"preferred": "vision-model", "capabilities": {"tool_use"}})
+        assert model.name == "vision-model"
+
+    def test_select_from_decisions_with_empty_set(self, registry):
+        selector = ModelSelector(registry)
+        model = selector.select_from_decisions(set())
+        assert model.name == "fast-model"
+
+    def test_select_for_avoid_list(self, registry):
+        """Avoid certain models — prefer a non-avoided model."""
+        selector = ModelSelector(registry)
+        model = selector.select({"capabilities": {"chat"}, "avoid": {"fast-model"}})
+        assert model.name != "fast-model"