from __future__ import annotations import unittest from backend.services.model_provider_runtime import ModelProviderRuntime from core.model_route_chain import ( encode_model_route_chain, model_route_candidates, parse_model_route_chain, ) from engines.vision_provider import ( VisionProviderError, VisionRecognitionRequest, VisionRecognitionResult, ) class _UnusedModelService: pass class _FailingVisionProvider: provider_id = "plugin-vlm" def recognize_material(self, request: VisionRecognitionRequest) -> VisionRecognitionResult: raise VisionProviderError( "plugin route failed", provider_id=self.provider_id, error_type="provider_error", ) class _SuccessfulVisionProvider: provider_id = "astrbot-vlm" def recognize_material(self, request: VisionRecognitionRequest) -> VisionRecognitionResult: return VisionRecognitionResult( provider_id=self.provider_id, model="vlm", prompt="fallback prompt", ) class ModelRouteChainTests(unittest.TestCase): def test_legacy_routes_are_classified_without_rewriting(self) -> None: self.assertEqual(parse_model_route_chain("plugin-route").plugin, "plugin-route") self.assertEqual(parse_model_route_chain("astrbot:vlm").astrbot, "astrbot:vlm") def test_two_source_chain_keeps_plugin_before_astrbot(self) -> None: encoded = encode_model_route_chain("plugin-vlm", "astrbot:vlm") self.assertEqual(model_route_candidates(encoded), ("plugin-vlm", "astrbot:vlm")) def test_vision_runtime_falls_back_after_plugin_failure(self) -> None: route = encode_model_route_chain("plugin-vlm", "astrbot:vlm") runtime = ModelProviderRuntime(_UnusedModelService()) # type: ignore[arg-type] providers = { "plugin-vlm": _FailingVisionProvider(), "astrbot:vlm": _SuccessfulVisionProvider(), } runtime._vision_provider_for_single_route = providers.get # type: ignore[method-assign] provider = runtime.vision_provider_for_route({"route_name": route}) self.assertIsNotNone(provider) result = provider.recognize_material( VisionRecognitionRequest(display_name="sample", image_uri="data:image/png;base64,AA==") ) self.assertEqual(result.provider_id, "astrbot-vlm") self.assertEqual(result.raw_metadata["route_fallback_failures"][0]["provider_id"], "plugin-vlm") def test_text_runtime_falls_back_in_source_order(self) -> None: route = encode_model_route_chain("plugin-text", "astrbot:text") runtime = ModelProviderRuntime(_UnusedModelService()) # type: ignore[arg-type] def factory(candidate: str): if candidate == "plugin-text": def fail(_payload): raise RuntimeError("plugin unavailable") return fail return lambda _payload: {"route": candidate} runtime._structured_text_callable_for_single_route = factory # type: ignore[method-assign] completion = runtime.structured_text_callable(route) self.assertIsNotNone(completion) self.assertEqual(completion({"purpose": "test"}), {"route": "astrbot:text"}) def test_structured_vision_runtime_falls_back_in_source_order(self) -> None: route = encode_model_route_chain("plugin-review", "astrbot:review") runtime = ModelProviderRuntime(_UnusedModelService()) # type: ignore[arg-type] def factory(candidate: str, *, storage=None): del storage if candidate == "plugin-review": def fail(_payload): raise RuntimeError("plugin vision review unavailable") return fail return lambda _payload: {"route": candidate, "action": "allow"} runtime._structured_vision_callable_for_single_route = factory # type: ignore[method-assign] review = runtime.structured_vision_callable(route) self.assertIsNotNone(review) self.assertEqual( review({"image": {"image_uri": "data:image/png;base64,AA=="}}), {"route": "astrbot:review", "action": "allow"}, ) if __name__ == "__main__": unittest.main()