classifyre-cli 0.4.2__py3-none-any.whl

src/detectors/custom/runners/_feature_extraction.py

@@ -0,0 +1,138 @@
+"""Feature extraction (dense embeddings) pipeline runner."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from ....models.generated_detectors import FeatureExtractionPipelineSchema, Severity
+from ....models.generated_single_asset_scan_results import DetectionResult
+from ...dependencies import ensure_torch, require_module
+from ._base import _TEXT_CONTENT_TYPES, BaseRunner
+
+logger = logging.getLogger(__name__)
+
+
+def _chunk_text_with_offsets(
+    text: str, chunk_size: int | None, chunk_overlap: int
+) -> list[tuple[str, int]]:
+    """Return (chunk, char_offset) pairs. Returns [(text, 0)] when chunk_size is not set."""
+    if not chunk_size:
+        return [(text, 0)]
+    step = max(1, chunk_size - chunk_overlap)
+    return [(text[i : i + chunk_size], i) for i in range(0, len(text), step)]
+
+
+def _pool_hidden(
+    hidden: list[list[float]], pooling: str, normalize: bool
+) -> list[float] | list[list[float]] | None:
+    """Apply pooling strategy to per-token hidden states."""
+    try:
+        import numpy as np  # type: ignore[import-untyped]
+    except ImportError:
+        logger.warning("numpy is required for feature extraction pooling")
+        return None
+    arr = np.array(hidden, dtype=np.float32)
+    if pooling == "cls":
+        vector = arr[0]
+    elif pooling == "max":
+        vector = arr.max(axis=0)
+    elif pooling == "none":
+        return arr.tolist()  # type: ignore[no-any-return]
+    else:
+        vector = arr.mean(axis=0)
+    if normalize:
+        norm = float(np.linalg.norm(vector))
+        if norm > 0:
+            vector = vector / norm
+    return vector.tolist()  # type: ignore[no-any-return]
+
+
+class FeatureExtractionRunner(BaseRunner):
+    """Dense vector embeddings via a single HuggingFace feature-extraction pipeline."""
+
+    def __init__(
+        self,
+        schema: FeatureExtractionPipelineSchema,
+        detector_key: str = "",
+        detector_name: str = "",
+    ) -> None:
+        self._schema = schema
+        self._detector_key = detector_key
+        self._detector_name = detector_name
+        ensure_torch("feature_extraction", ["custom", "detectors"])
+        transformers = require_module("transformers", "feature_extraction", ["custom", "detectors"])
+        truncation = schema.truncation if schema.truncation is not None else True
+        tokenizer_kwargs: dict[str, Any] = {"truncation": truncation}
+        if schema.max_length is not None:
+            tokenizer_kwargs["max_length"] = schema.max_length
+        pipeline_kwargs: dict[str, Any] = {
+            "model": schema.model,
+            "device": schema.device or "cpu",
+            "tokenizer_kwargs": tokenizer_kwargs,
+        }
+        if schema.model_revision:
+            pipeline_kwargs["revision"] = schema.model_revision
+        self._pipe: Any = transformers.pipeline("feature-extraction", **pipeline_kwargs)
+
+    def run(self, text: str) -> None:  # type: ignore[override]  # pragma: no cover
+        raise NotImplementedError("FeatureExtractionRunner uses detect() directly")
+
+    def detect(self, content: str | bytes, content_type: str) -> list[DetectionResult]:
+        if isinstance(content, bytes):
+            return []
+        if content_type not in _TEXT_CONTENT_TYPES:
+            return []
+        text = content.strip()
+        if not text:
+            return []
+
+        schema = self._schema
+        pooling = str(schema.pooling_strategy or "mean")
+        normalize = schema.normalize_embeddings if schema.normalize_embeddings is not None else True
+        chunk_size: int | None = getattr(schema.chunk_size, "root", schema.chunk_size)
+        chunk_overlap: int = getattr(schema.chunk_overlap, "root", schema.chunk_overlap) or 0
+
+        results: list[DetectionResult] = []
+        try:
+            for chunk, offset in _chunk_text_with_offsets(text, chunk_size, chunk_overlap):
+                raw: list[list[list[float]]] = self._pipe(chunk) or []
+                if not raw or not raw[0]:
+                    continue
+                embedding = _pool_hidden(raw[0], pooling, normalize)
+                if embedding is None:
+                    continue
+                dim: int | None
+                if pooling == "none":
+                    dim = (
+                        len(embedding[0]) if embedding and isinstance(embedding[0], list) else None
+                    )  # type: ignore[index]
+                else:
+                    dim = len(embedding)  # type: ignore[arg-type]
+                results.append(
+                    self._make_result(
+                        finding_type="embedding",
+                        category="CLASSIFICATION",
+                        severity=Severity.info,
+                        confidence=1.0,
+                        matched_content=chunk[:256],
+                        location=None,
+                        metadata={
+                            "embedding": embedding,
+                            "dimension": dim,
+                            "pooling_strategy": pooling,
+                            "normalized": normalize,
+                            "model": schema.model,
+                            "chunk_offset": offset,
+                            "chunk_length": len(chunk),
+                        },
+                    )
+                )
+        except Exception as exc:
+            logger.error(
+                "feature_extraction error (model=%s): %s", schema.model, exc, exc_info=True
+            )
+        return results
+
+    def get_supported_content_types(self) -> list[str]:
+        return list(_TEXT_CONTENT_TYPES)

src/detectors/custom/runners/_gliner2.py

@@ -0,0 +1,324 @@
+"""GLiNER2 pipeline runner."""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import time
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from ....models.generated_detectors import (
+    GLiNER2PipelineSchema,
+    PipelineEntityDefinition,
+    PipelineResult,
+    PipelineValidationConfig,
+)
+from ...dependencies import MissingDependencyError, require_module
+from ._base import _DEFAULT_GLINER2_MODEL, BaseRunner
+
+logger = logging.getLogger(__name__)
+
+
+class GLiNER2Runner(BaseRunner):
+    """Execute a GLiNER2 pipeline: single-model pass for entities + classification.
+
+    When the pipeline schema's model.path points to a trained artifact directory
+    (written by trainer.py), the runner:
+      - loads the fine-tuned GLiNER2 weights from <path>/gliner2/ if present
+      - uses per-task SetFit models from <path>/setfit/<task>/ for classification
+    """
+
+    def __init__(
+        self, schema: GLiNER2PipelineSchema, detector_key: str = "", detector_name: str = ""
+    ) -> None:
+        self._schema = schema
+        self._detector_key = detector_key
+        self._detector_name = detector_name
+        self._model: Any | None = None
+        self._setfit_models: dict[str, Any] | None = None
+        self._setfit_labels: dict[str, list[str]] = {}
+        self._artifact_dir: Path | None = None
+        self._init_artifact_dir()
+
+    def _init_artifact_dir(self) -> None:
+        model_cfg = self._schema.model
+        if not model_cfg or not model_cfg.path:
+            return
+        candidate = Path(model_cfg.path)
+        if candidate.is_dir() and (candidate / "manifest.json").exists():
+            self._artifact_dir = candidate
+            logger.info(
+                "Artifact directory detected for detector '%s': %s",
+                self._detector_key,
+                candidate,
+            )
+
+    def run(self, text: str) -> PipelineResult:
+        start_ms = time.monotonic()
+        model = self._load_model()
+        if model is None:
+            return PipelineResult()
+
+        entity_schema = self._build_entity_schema()
+        classification_tasks = self._build_classification_tasks()
+
+        raw_entities: dict[str, list[dict[str, object]]] = {}
+        raw_classification: dict[str, dict[str, object]] = {}
+
+        try:
+            if entity_schema:
+                raw = model.extract_entities(
+                    text,
+                    entity_schema,
+                    threshold=0.0,
+                    include_confidence=True,
+                    include_spans=True,
+                )
+                raw_entities = _normalise_entity_output(raw, text)
+
+            for task_name, labels in classification_tasks.items():
+                setfit = self._get_setfit_model(task_name)
+                if setfit is not None:
+                    raw_cls = self._run_setfit(setfit, task_name, text)
+                else:
+                    raw_cls = model.classify(text, labels, threshold=0.0)
+                raw_classification[task_name] = _normalise_classification_output(raw_cls)
+
+        except Exception as exc:  # pragma: no cover - runtime specific
+            logger.error("GLiNER2 pipeline failed for detector '%s': %s", self._detector_key, exc)
+            return PipelineResult()
+
+        validation = self._schema.validation or PipelineValidationConfig()
+        filtered_entities = _apply_entity_validation(raw_entities, validation, self._schema)
+        filtered_classification = _apply_classification_validation(raw_classification, validation)
+
+        latency_ms = round((time.monotonic() - start_ms) * 1000)
+        model_cfg = self._schema.model
+        model_name = (
+            model_cfg.name if model_cfg else _DEFAULT_GLINER2_MODEL
+        ) or _DEFAULT_GLINER2_MODEL
+        runner_tag = "GLINER2+ARTIFACT" if self._artifact_dir else "GLINER2"
+
+        return PipelineResult(
+            entities=filtered_entities,
+            classification=filtered_classification,
+            metadata={
+                "model": model_name,
+                "runner": runner_tag,
+                "latency_ms": latency_ms,
+                "timestamp": datetime.now(UTC).isoformat(),
+            },
+        )
+
+    def _load_model(self) -> Any | None:
+        if self._model is not None:
+            return self._model
+
+        if self._artifact_dir is not None:
+            gliner_path = self._artifact_dir / "gliner2"
+            if gliner_path.is_dir():
+                model_name = str(gliner_path)
+                logger.info(
+                    "Loading fine-tuned GLiNER2 from '%s' for detector '%s'",
+                    model_name,
+                    self._detector_key,
+                )
+                try:
+                    gliner2_module = require_module(
+                        "gliner2", "custom", ["classification", "detectors"]
+                    )
+                    self._model = gliner2_module.GLiNER2.from_pretrained(model_name)
+                    return self._model
+                except Exception as exc:
+                    logger.warning("Failed to load fine-tuned GLiNER2, falling back: %s", exc)
+
+        model_cfg = self._schema.model
+        if model_cfg and model_cfg.path and not self._artifact_dir:
+            model_name = model_cfg.path
+        elif model_cfg and model_cfg.name:
+            model_name = model_cfg.name
+        else:
+            model_name = _DEFAULT_GLINER2_MODEL
+
+        try:
+            gliner2_module = require_module("gliner2", "custom", ["classification", "detectors"])
+            self._model = gliner2_module.GLiNER2.from_pretrained(model_name)
+            logger.info(
+                "GLiNER2 model '%s' loaded for detector '%s'", model_name, self._detector_key
+            )
+            return self._model
+        except MissingDependencyError:
+            raise
+        except Exception as exc:  # pragma: no cover - environment specific
+            logger.warning(
+                "Failed to load GLiNER2 model '%s' for detector '%s': %s",
+                model_name,
+                self._detector_key,
+                exc,
+            )
+            return None
+
+    def _get_setfit_model(self, task_name: str) -> Any | None:
+        """Return the SetFit model for task_name if a trained artifact exists."""
+        if self._artifact_dir is None:
+            return None
+
+        if self._setfit_models is None:
+            self._setfit_models = {}
+
+        if task_name in self._setfit_models:
+            return self._setfit_models[task_name]
+
+        model_path = self._artifact_dir / "setfit" / task_name
+        labels_path = model_path / "labels.json"
+        if not model_path.is_dir() or not labels_path.exists():
+            self._setfit_models[task_name] = None
+            return None
+
+        try:
+            from setfit import SetFitModel  # type: ignore[import-untyped]
+
+            sfm = SetFitModel.from_pretrained(str(model_path))
+            self._setfit_models[task_name] = sfm
+            self._setfit_labels[task_name] = json.loads(labels_path.read_text())
+            logger.info("SetFit model for task '%s' loaded from '%s'", task_name, model_path)
+            return sfm
+        except Exception as exc:
+            logger.warning("Failed to load SetFit model for task '%s': %s", task_name, exc)
+            self._setfit_models[task_name] = None
+            return None
+
+    def _run_setfit(self, model: Any, task_name: str, text: str) -> dict[str, object]:
+        """Run a SetFit model and return a label/confidence dict."""
+        try:
+            import torch  # type: ignore[import-untyped]
+
+            labels = self._setfit_labels.get(task_name, [])
+            with torch.no_grad():
+                probs = model.predict_proba([text])
+            prob_row = probs[0].tolist() if hasattr(probs[0], "tolist") else list(probs[0])
+            best_idx = int(max(range(len(prob_row)), key=lambda i: prob_row[i]))
+            best_label = labels[best_idx] if best_idx < len(labels) else str(best_idx)
+            best_conf = float(prob_row[best_idx]) if best_idx < len(prob_row) else 0.0
+            return {"label": best_label, "confidence": round(best_conf, 4)}
+        except Exception as exc:
+            logger.warning("SetFit inference failed for task '%s': %s", task_name, exc)
+            return {}
+
+    def _build_entity_schema(self) -> dict[str, str]:
+        entities = self._schema.entities or {}
+        return {
+            label: defn.description if isinstance(defn, PipelineEntityDefinition) else str(defn)
+            for label, defn in entities.items()
+        }
+
+    def _build_classification_tasks(self) -> dict[str, list[str]]:
+        return {task: defn.labels for task, defn in (self._schema.classification or {}).items()}
+
+
+# ── Normalisation helpers (used only by GLiNER2Runner) ────────────────────────
+
+
+def _normalise_entity_output(raw: dict[str, Any], text: str) -> dict[str, list[dict[str, object]]]:
+    result: dict[str, list[dict[str, object]]] = {}
+    entities = raw.get("entities", raw)
+    if not isinstance(entities, dict):
+        return result
+
+    for label, spans in entities.items():
+        span_list: list[Any] = spans if isinstance(spans, list) else [spans]
+        normalised = [s for s in (_normalise_span(span, text) for span in span_list) if s]
+        if normalised:
+            result[label] = normalised
+
+    return result
+
+
+def _normalise_span(span: Any, text: str) -> dict[str, object] | None:
+    if isinstance(span, dict):
+        value = str(span.get("text", "")).strip()
+        confidence = float(span.get("confidence", span.get("score", 0.0)))
+        start = span.get("start")
+        end = span.get("end")
+    else:
+        value = str(span).strip()
+        confidence = 1.0
+        start = None
+        end = None
+
+    if not value and isinstance(start, int) and isinstance(end, int):
+        value = text[start:end].strip()
+    if not value:
+        return None
+
+    if not isinstance(start, int) or not isinstance(end, int):
+        start = text.find(value)
+        end = start + len(value) if start >= 0 else -1
+
+    if start < 0:
+        return None
+
+    return {"value": value, "confidence": round(confidence, 4), "start": start, "end": end}
+
+
+def _normalise_classification_output(raw: Any) -> dict[str, object]:
+    if isinstance(raw, dict):
+        label = raw.get("label", "")
+        confidence = float(raw.get("confidence", raw.get("score", 0.0)))
+    elif isinstance(raw, (list, tuple)) and raw:
+        best = max(raw, key=lambda x: x.get("score", 0.0) if isinstance(x, dict) else 0.0)
+        label = best.get("label", "") if isinstance(best, dict) else str(best)
+        confidence = float(best.get("score", 0.0)) if isinstance(best, dict) else 1.0
+    else:
+        return {}
+
+    return {"label": label, "confidence": round(confidence, 4)}
+
+
+def _apply_entity_validation(
+    entities: dict[str, list[dict[str, object]]],
+    validation: PipelineValidationConfig,
+    schema: GLiNER2PipelineSchema,
+) -> dict[str, list[dict[str, object]]]:
+    threshold = validation.confidence_threshold or 0.7
+    result: dict[str, list[dict[str, object]]] = {}
+
+    for label, spans in entities.items():
+        passing = [
+            span
+            for span in spans
+            if isinstance(span.get("confidence"), (int, float))
+            and float(span["confidence"]) >= threshold  # type: ignore[arg-type]
+        ]
+        for rule in validation.rules or []:
+            if rule.field == label and rule.type == "regex" and rule.pattern:
+                try:
+                    rx = re.compile(rule.pattern)
+                    passing = [s for s in passing if rx.search(str(s.get("value", "")))]
+                except re.error as exc:
+                    logger.warning("Invalid validation regex for field '%s': %s", label, exc)
+        if passing:
+            result[label] = passing
+
+    for label, defn in (schema.entities or {}).items():
+        if isinstance(defn, PipelineEntityDefinition) and defn.required and label not in result:
+            logger.debug("Required entity '%s' not found — suppressing all findings", label)
+            return {}
+
+    return result
+
+
+def _apply_classification_validation(
+    classification: dict[str, dict[str, object]],
+    validation: PipelineValidationConfig,
+) -> dict[str, dict[str, object]]:
+    threshold = validation.confidence_threshold or 0.7
+    return {
+        task: outcome
+        for task, outcome in classification.items()
+        if isinstance(outcome.get("confidence", 0.0), (int, float))
+        and float(outcome["confidence"]) >= threshold  # type: ignore[arg-type]
+    }

src/detectors/custom/runners/_image_classification.py

@@ -0,0 +1,98 @@
+"""Image classification pipeline runner."""
+
+from __future__ import annotations
+
+import io
+import logging
+from typing import Any
+
+from ....models.generated_detectors import ImageClassificationPipelineSchema
+from ....models.generated_single_asset_scan_results import DetectionResult
+from ...dependencies import ensure_torch, require_module
+from ._base import (
+    _DEFAULT_IMAGE_CLASSIFICATION_MODEL,
+    _IMAGE_CONTENT_TYPES,
+    BaseRunner,
+    _resolve_pipeline_severity,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class ImageClassificationRunner(BaseRunner):
+    """Image classification via a single HuggingFace image-classification pipeline."""
+
+    def __init__(
+        self,
+        schema: ImageClassificationPipelineSchema,
+        detector_key: str = "",
+        detector_name: str = "",
+    ) -> None:
+        self._schema = schema
+        self._detector_key = detector_key
+        self._detector_name = detector_name
+        ensure_torch("image_classification", ["custom", "detectors"])
+        transformers = require_module(
+            "transformers", "image_classification", ["custom", "detectors"]
+        )
+        self._pil = require_module("PIL.Image", "image_classification", ["custom", "detectors"])
+        model_id = schema.model or _DEFAULT_IMAGE_CLASSIFICATION_MODEL
+        pipeline_kwargs: dict[str, Any] = {
+            "model": model_id,
+            "device": schema.device or "cpu",
+        }
+        if schema.model_revision:
+            pipeline_kwargs["revision"] = schema.model_revision
+        if schema.top_k is not None:
+            pipeline_kwargs["top_k"] = schema.top_k
+        if schema.function_to_apply is not None:
+            pipeline_kwargs["function_to_apply"] = str(schema.function_to_apply)
+        self._pipe: Any = transformers.pipeline("image-classification", **pipeline_kwargs)
+        self._model_id = model_id
+
+    def run(self, text: str) -> None:  # type: ignore[override]  # pragma: no cover
+        raise NotImplementedError("ImageClassificationRunner uses detect() directly")
+
+    def detect(self, content: str | bytes, content_type: str) -> list[DetectionResult]:
+        if not content_type.startswith("image/"):
+            return []
+        if isinstance(content, str):
+            logger.warning("image_classification: received string content, expected bytes")
+            return []
+
+        schema = self._schema
+        threshold = schema.confidence_threshold if schema.confidence_threshold is not None else 0.0
+        results: list[DetectionResult] = []
+        try:
+            image = self._pil.open(io.BytesIO(content))
+            predictions: list[dict[str, Any]] = self._pipe(image) or []
+            for pred in predictions:
+                label: str = pred.get("label", "unknown")
+                score: float = float(pred.get("score", 0.0))
+                if score < threshold:
+                    continue
+                severity = _resolve_pipeline_severity(label, schema.severity_map)
+                results.append(
+                    self._make_result(
+                        finding_type=f"classification:{label}",
+                        category="CONTENT",
+                        severity=severity,
+                        confidence=score,
+                        matched_content=f"Image classified as: {label} ({score:.3f})",
+                        location=None,
+                        metadata={
+                            "image_size": f"{image.size[0]}x{image.size[1]}",
+                            "image_mode": image.mode,
+                            "model": self._model_id,
+                        },
+                    )
+                )
+        except Exception as exc:
+            logger.error(
+                "image_classification error (model=%s): %s", self._model_id, exc, exc_info=True
+            )
+        results.sort(key=lambda r: r.confidence, reverse=True)
+        return results
+
+    def get_supported_content_types(self) -> list[str]:
+        return list(_IMAGE_CONTENT_TYPES)

src/detectors/custom/runners/_llm.py

@@ -0,0 +1,22 @@
+"""LLM pipeline runner (stub — not yet implemented)."""
+
+from __future__ import annotations
+
+from ....models.generated_detectors import LLMPipelineSchema, PipelineResult
+from ._base import BaseRunner
+
+
+class LLMRunner(BaseRunner):
+    """LLM-based detection — not yet implemented."""
+
+    def __init__(
+        self, schema: LLMPipelineSchema, detector_key: str = "", detector_name: str = ""
+    ) -> None:
+        self._schema = schema
+        self._detector_key = detector_key
+        self._detector_name = detector_name
+
+    def run(self, text: str) -> PipelineResult:  # pragma: no cover - stub
+        raise NotImplementedError(
+            f"LLM runner is not yet implemented (detector '{self._detector_key}')"
+        )

src/detectors/custom/runners/_object_detection.py

@@ -0,0 +1,107 @@
+"""Object detection pipeline runner."""
+
+from __future__ import annotations
+
+import io
+import logging
+from typing import Any
+
+from ....models.generated_detectors import ObjectDetectionPipelineSchema
+from ....models.generated_single_asset_scan_results import DetectionResult, Location
+from ...dependencies import MissingDependencyError, ensure_torch, require_module
+from ._base import _IMAGE_CONTENT_TYPES, BaseRunner, _resolve_pipeline_severity
+
+logger = logging.getLogger(__name__)
+
+
+class ObjectDetectionRunner(BaseRunner):
+    """Object detection via a single HuggingFace object-detection pipeline."""
+
+    def __init__(
+        self,
+        schema: ObjectDetectionPipelineSchema,
+        detector_key: str = "",
+        detector_name: str = "",
+    ) -> None:
+        self._schema = schema
+        self._detector_key = detector_key
+        self._detector_name = detector_name
+        ensure_torch("object_detection", ["custom", "detectors"])
+        transformers = require_module("transformers", "object_detection", ["custom", "detectors"])
+        self._pil = require_module("PIL.Image", "object_detection", ["custom", "detectors"])
+        pipeline_kwargs: dict[str, Any] = {
+            "model": schema.model,
+            "device": schema.device or "cpu",
+        }
+        if schema.model_revision:
+            pipeline_kwargs["revision"] = schema.model_revision
+        nms = getattr(schema.nms_threshold, "root", schema.nms_threshold)
+        if nms is not None:
+            pipeline_kwargs["threshold"] = nms
+        try:
+            self._pipe: Any = transformers.pipeline("object-detection", **pipeline_kwargs)
+        except ImportError as exc:
+            raise MissingDependencyError(
+                "object_detection",
+                ["custom", "detectors"],
+                f"ObjectDetectionRunner requires additional dependencies: {exc}",
+            ) from exc
+
+    def run(self, text: str) -> None:  # type: ignore[override]  # pragma: no cover
+        raise NotImplementedError("ObjectDetectionRunner uses detect() directly")
+
+    def detect(self, content: str | bytes, content_type: str) -> list[DetectionResult]:
+        if not content_type.startswith("image/"):
+            return []
+        if isinstance(content, str):
+            logger.warning("object_detection: received string content, expected bytes")
+            return []
+
+        schema = self._schema
+        threshold = schema.confidence_threshold if schema.confidence_threshold is not None else 0.5
+        results: list[DetectionResult] = []
+        try:
+            image = self._pil.open(io.BytesIO(content))
+            detections: list[dict[str, Any]] = self._pipe(image) or []
+            for det in detections:
+                label: str = det.get("label", "unknown")
+                score: float = float(det.get("score", 0.0))
+                box: dict[str, int] = det.get("box", {})
+                if score < threshold:
+                    continue
+                if schema.min_box_area is not None:
+                    w = max(0, box.get("xmax", 0) - box.get("xmin", 0))
+                    h = max(0, box.get("ymax", 0) - box.get("ymin", 0))
+                    if w * h < schema.min_box_area:
+                        continue
+                severity = _resolve_pipeline_severity(label, schema.severity_map)
+                results.append(
+                    self._make_result(
+                        finding_type=f"entity:{label}",
+                        category="CONTENT",
+                        severity=severity,
+                        confidence=score,
+                        matched_content=f"Detected: {label} ({score:.3f})",
+                        location=Location(
+                            description=(
+                                f"box xmin={box.get('xmin')} ymin={box.get('ymin')}"
+                                f" xmax={box.get('xmax')} ymax={box.get('ymax')}"
+                            ),
+                        ),
+                        metadata={
+                            "box": box,
+                            "score": score,
+                            "image_size": f"{image.size[0]}x{image.size[1]}",
+                            "model": schema.model,
+                        },
+                    )
+                )
+            results.sort(key=lambda r: r.confidence, reverse=True)
+            if schema.top_k is not None:
+                results = results[: schema.top_k]
+        except Exception as exc:
+            logger.error("object_detection error (model=%s): %s", schema.model, exc, exc_info=True)
+        return results
+
+    def get_supported_content_types(self) -> list[str]:
+        return list(_IMAGE_CONTENT_TYPES)