From 778f8d83149f3538fe7184b6bea9a1a760758d97 Mon Sep 17 00:00:00 2001 From: YokiiroBW Date: Sun, 5 Jul 2026 11:00:49 +0800 Subject: [PATCH] feat: add api discovery overrides --- backend/route_registry.py | 2 + backend/routes/api_discovery_routes.py | 28 +++++++++++ backend/services/api_discovery_service.py | 44 ++++++++++++++++ tests/test_api_discovery_service.py | 61 ++++++++++++++++++++++- 4 files changed, 133 insertions(+), 2 deletions(-) diff --git a/backend/route_registry.py b/backend/route_registry.py index 1245b91..a1b621f 100644 --- a/backend/route_registry.py +++ b/backend/route_registry.py @@ -87,7 +87,9 @@ ROUTES: tuple[RouteSpec, ...] = ( RouteSpec("GET", "security/audit-logs", "backend.routes.log_routes.get_audit_logs", "config"), RouteSpec("GET", "api-discovery/dialects", "backend.routes.api_discovery_routes.list_dialects", "read"), RouteSpec("POST", "api-discovery/probe-provider", "backend.routes.api_discovery_routes.probe_provider", "config"), + RouteSpec("POST", "api-discovery/probe-model", "backend.routes.api_discovery_routes.probe_model", "config"), RouteSpec("GET", "api-discovery/capabilities", "backend.routes.api_discovery_routes.list_capabilities", "read"), + RouteSpec("POST", "api-discovery/manual-override", "backend.routes.api_discovery_routes.manual_override", "config"), RouteSpec("POST", "api-discovery/validate-render-plan", "backend.routes.api_discovery_routes.validate_render_plan", "read"), RouteSpec("GET", "web/manifest", "backend.routes.web_routes.get_web_manifest", "read"), ) diff --git a/backend/routes/api_discovery_routes.py b/backend/routes/api_discovery_routes.py index a6e1924..93dfb85 100644 --- a/backend/routes/api_discovery_routes.py +++ b/backend/routes/api_discovery_routes.py @@ -36,6 +36,34 @@ def probe_provider( return handle_request(ctx, action) +def probe_model( + ctx: RequestContext, + payload: dict[str, Any], + service: ApiDiscoveryService | None = None, +) -> dict: + discovery_service = service or _create_discovery_service() + + def action() -> dict[str, Any]: + require_config_manager(ctx) + return discovery_service.probe_model(payload) + + return handle_request(ctx, action) + + +def manual_override( + ctx: RequestContext, + payload: dict[str, Any], + service: ApiDiscoveryService | None = None, +) -> dict: + discovery_service = service or _create_discovery_service() + + def action() -> dict[str, Any]: + require_config_manager(ctx) + return discovery_service.manual_override(payload) + + return handle_request(ctx, action) + + def list_capabilities(ctx: RequestContext, service: ApiDiscoveryService | None = None) -> dict: discovery_service = service or _create_discovery_service() diff --git a/backend/services/api_discovery_service.py b/backend/services/api_discovery_service.py index 7befb44..8c892ca 100644 --- a/backend/services/api_discovery_service.py +++ b/backend/services/api_discovery_service.py @@ -59,6 +59,50 @@ class ApiDiscoveryService: ) return profile + def probe_model(self, payload: dict[str, Any]) -> dict[str, Any]: + profile = self.probe_provider(payload) + profile["probe_result"] = { + **profile.get("probe_result", {}), + "model_probe": "safe_metadata_only", + } + return self.repository.update_profile( + profile["capability_profile_id"], + {"probe_result": profile["probe_result"]}, + ) or profile + + def manual_override(self, payload: dict[str, Any]) -> dict[str, Any]: + provider_id = str(payload.get("provider_id") or "").strip() + model_id = str(payload.get("model_id") or "").strip() + status = str(payload.get("status") or "").strip() + if status not in {"confirmed_supported", "confirmed_unsupported", "unconfirmed"}: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "unsupported capability status", + {"field": "status"}, + ) + profile = self.repository.get_profile(provider_id, model_id) + if profile is None: + profile = self.repository.upsert_profile( + { + "capability_profile_id": payload.get("capability_profile_id") or new_capability_profile_id(), + "provider_id": provider_id, + "model_id": model_id, + "dialect": payload.get("dialect", "unknown"), + "status": status, + "capabilities": payload.get("capabilities") or {}, + "probe_result": {"manual": True}, + } + ) + return self.repository.update_profile( + profile["capability_profile_id"], + { + "status": status, + "dialect": payload.get("dialect", profile["dialect"]), + "capabilities": payload.get("capabilities", profile["capabilities"]), + "probe_result": {**profile.get("probe_result", {}), "manual_override": True}, + }, + ) or profile + def capabilities(self) -> list[dict[str, Any]]: return self.repository.list_profiles() diff --git a/tests/test_api_discovery_service.py b/tests/test_api_discovery_service.py index 33abb24..db2595f 100644 --- a/tests/test_api_discovery_service.py +++ b/tests/test_api_discovery_service.py @@ -4,7 +4,14 @@ import tempfile import unittest from pathlib import Path -from backend.routes.api_discovery_routes import list_capabilities, list_dialects, probe_provider, validate_render_plan +from backend.routes.api_discovery_routes import ( + list_capabilities, + list_dialects, + manual_override, + probe_model, + probe_provider, + validate_render_plan, +) from backend.services.api_discovery_service import ApiDiscoveryService from core.identity import RequestContext from database.db_helper import Database, DatabaseSettings, SqliteSettings @@ -86,6 +93,36 @@ class ApiDiscoveryServiceTests(unittest.TestCase): self.assertFalse(invalid["valid"]) self.assertEqual(invalid["errors"][0]["code"], "MODEL_CAPABILITY_UNSUPPORTED") + def test_probe_model_and_manual_override(self): + probed = self.service.probe_model( + { + "provider_id": "local_provider", + "model_id": "image_high", + "dialect": "openai_images", + } + ) + self.assertEqual(probed["probe_result"]["model_probe"], "safe_metadata_only") + + overridden = self.service.manual_override( + { + "provider_id": "local_provider", + "model_id": "image_high", + "status": "confirmed_supported", + "capabilities": {"supports": ["text_to_image", "image_edit"]}, + } + ) + self.assertEqual(overridden["status"], "confirmed_supported") + self.assertIn("image_edit", overridden["capabilities"]["supports"]) + + render_plan = self.service.validate_render_plan( + { + "provider_id": "local_provider", + "model_id": "image_high", + "required_capabilities": ["image_edit"], + } + ) + self.assertTrue(render_plan["valid"]) + def test_api_discovery_routes_wrap_responses(self): dialects = list_dialects(self.ctx, self.service) self.assertTrue(dialects["ok"]) @@ -98,6 +135,25 @@ class ApiDiscoveryServiceTests(unittest.TestCase): ) self.assertTrue(probed["ok"]) + model_probe = probe_model( + self.ctx, + {"provider_id": "local_provider", "model_id": "image_low"}, + self.service, + ) + self.assertTrue(model_probe["ok"]) + + override = manual_override( + self.ctx, + { + "provider_id": "local_provider", + "model_id": "image_low", + "status": "confirmed_supported", + "capabilities": {"supports": ["text_to_image"]}, + }, + self.service, + ) + self.assertTrue(override["ok"]) + capabilities = list_capabilities(self.ctx, self.service) self.assertTrue(capabilities["ok"]) self.assertEqual(len(capabilities["data"]), 1) @@ -112,7 +168,8 @@ class ApiDiscoveryServiceTests(unittest.TestCase): self.service, ) self.assertTrue(validation["ok"]) - self.assertEqual(validation["data"]["status"], "unconfirmed") + self.assertTrue(validation["data"]["valid"]) + self.assertEqual(validation["data"]["status"], "confirmed_supported") read_only = RequestContext.from_astrbot(username="viewer", user_id="viewer_001") denied = probe_provider(read_only, {"provider_id": "x", "model_id": "y"}, self.service)