feat(discover): inject backend type tag into resource tags

Add 'backend:<TYPE>' tag to each resource returned by adp.discover,
allowing agents to distinguish backend types (e.g. RDBMS, BLOB_STORAGE)
without inspecting field-level convention fields.

- _to_resource() now accepts a BackendDefinition | None parameter
- handle() passes the resolved backend to _to_resource()
- Tags are created if absent; existing tags are preserved
- If backend is None (e.g. unresolvable), no tag is injected

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: mchades

src/adp_hypervisor/handlers/discover.py

@@ -42,6 +42,7 @@
 
 if TYPE_CHECKING:
     from adp_hypervisor.manifest.index import ManifestIndex
+    from adp_hypervisor.manifest.physical import BackendDefinition
     from adp_hypervisor.manifest.semantic import CuratedResource
 
 logger = logging.getLogger(__name__)
@@ -85,15 +86,22 @@ def _expand_intent_classes(intent_classes: list[IntentClass] | None) -> list[Int
     return intent_classes
 
 
-def _to_resource(curated: CuratedResource) -> Resource:
-    """Convert a CuratedResource to a protocol Resource (strip curation-specific fields)."""
+def _to_resource(curated: CuratedResource, backend: BackendDefinition | None = None) -> Resource:
+    """Convert a CuratedResource to a protocol Resource (strip curation-specific fields).
+
+    If a backend definition is provided, a ``"backend:<TYPE>"`` tag is appended
+    so that clients can identify the backend type without a separate describe call.
+    """
+    tags = list(curated.tags or [])
+    if backend is not None:
+        tags.append(f"backend:{backend.type}")
     return Resource(
         resource_id=curated.resource_id,
         version=curated.version,
         intent_classes=_expand_intent_classes(curated.intent_classes),
         description=curated.description,
         semantic_description=curated.semantic_description,
-        tags=curated.tags,
+        tags=tags if tags else None,
     )
 
 
@@ -223,6 +231,8 @@ async def handle(self, params: dict[str, Any]) -> BaseModel:
         )
 
         return DiscoverResult(
-            resources=[_to_resource(r) for r in page],
+            resources=[
+                _to_resource(r, self._manifest_index.get_backend(r.backend_id)) for r in page
+            ],
             next_cursor=next_cursor,
         )

tests/unit/handlers/test_discover.py

@@ -95,6 +95,7 @@ def _make_resource(
 def _mock_manifest(resources: list[CuratedResource] | None = None) -> ManifestIndex:
     index = MagicMock(spec=ManifestIndex)
     index.list_resources.return_value = resources if resources is not None else _SAMPLE_RESOURCES
+    index.get_backend.return_value = None
     return index
 
 
@@ -619,3 +620,59 @@ async def test_no_accessible_resources(self) -> None:
         data = result.model_dump(by_alias=True, exclude_none=True)
 
         self.assertEqual(data["resources"], [])
+
+
+# =============================================================================
+class TestDiscoverBackendTagInjection(unittest.IsolatedAsyncioTestCase):
+    """Backend type tag is injected into resource tags during discover."""
+
+    async def test_backend_tag_appended(self) -> None:
+        """Resources get a 'backend:<TYPE>' tag from the backend definition."""
+        from unittest.mock import MagicMock
+
+        from adp_hypervisor.manifest.physical import BackendDefinition, BackendType
+
+        backend_def = MagicMock(spec=BackendDefinition)
+        backend_def.type = BackendType.RDBMS
+
+        index = _mock_manifest(
+            [_make_resource("demo:orders", intent_classes=["QUERY"], tags=["FINANCE"])]
+        )
+        index.get_backend.return_value = backend_def
+
+        handler = DiscoverHandler(manifest_index=index, policy_enforcer=_mock_policy_enforcer())
+        result = await handler.handle(_make_params())
+        data = result.model_dump(by_alias=True, exclude_none=True)
+
+        tags = data["resources"][0]["tags"]
+        self.assertIn("FINANCE", tags)
+        self.assertIn("backend:RDBMS", tags)
+
+    async def test_backend_tag_no_existing_tags(self) -> None:
+        """Backend tag is injected even when the resource has no existing tags."""
+        from unittest.mock import MagicMock
+
+        from adp_hypervisor.manifest.physical import BackendDefinition, BackendType
+
+        backend_def = MagicMock(spec=BackendDefinition)
+        backend_def.type = BackendType.BLOB_STORAGE
+
+        index = _mock_manifest([_make_resource("demo:docs", intent_classes=["QUERY"])])
+        index.get_backend.return_value = backend_def
+
+        handler = DiscoverHandler(manifest_index=index, policy_enforcer=_mock_policy_enforcer())
+        result = await handler.handle(_make_params())
+        data = result.model_dump(by_alias=True, exclude_none=True)
+
+        self.assertEqual(data["resources"][0]["tags"], ["backend:BLOB_STORAGE"])
+
+    async def test_no_backend_tag_when_backend_missing(self) -> None:
+        """When get_backend returns None, no backend tag is injected."""
+        index = _mock_manifest([_make_resource("demo:orphan", intent_classes=["QUERY"])])
+        index.get_backend.return_value = None
+
+        handler = DiscoverHandler(manifest_index=index, policy_enforcer=_mock_policy_enforcer())
+        result = await handler.handle(_make_params())
+        data = result.model_dump(by_alias=True, exclude_none=True)
+
+        self.assertNotIn("tags", data["resources"][0])