110 行
4.2 KiB
Python
110 行
4.2 KiB
Python
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()
|