classifyre-cli 0.4.134__tar.gz → 0.4.135__tar.gz

classifyre_cli-0.4.135/.turbo/turbo-build.log

@@ -0,0 +1,3 @@
+$ uv sync
+Resolved 323 packages in 217ms
+Checked 51 packages in 4ms

{classifyre_cli-0.4.134 → classifyre_cli-0.4.135}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: classifyre-cli
-Version: 0.4.134
+Version: 0.4.135
 Summary: Classifyre CLI — scan and classify unstructured data sources
 License: MIT
 Keywords: data,ingestion,metadata,pii,secrets,unstructured

{classifyre_cli-0.4.134 → classifyre_cli-0.4.135}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@classifyre/cli",
-  "version": "0.4.134",
+  "version": "0.4.135",
   "private": true,
   "scripts": {
     "build": "uv sync",

{classifyre_cli-0.4.134 → classifyre_cli-0.4.135}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "classifyre-cli"
-version = "0.4.134"
+version = "0.4.135"
 description = "Classifyre CLI — scan and classify unstructured data sources"
 readme = "README.md"
 requires-python = ">=3.12"

{classifyre_cli-0.4.134 → classifyre_cli-0.4.135}/scripts/generate_models.py

@@ -14,14 +14,19 @@ _PIPELINE_TYPE_DEFAULTS: dict[str, str] = {
     "GLiNER2PipelineSchema": "GLINER2",
     "RegexPipelineSchema": "REGEX",
     "LLMPipelineSchema": "LLM",
+    "TagPipelineSchema": "TAG",
 }
 
 # Pipeline schema classes whose `severity` field has a string default from JSON schema
 # ('info') but must be an enum instance to avoid Pydantic serialization warnings
 # ("Expected `enum` - serialized value may not be as expected").
+# Maps class name -> the severity member its JSON-schema default names. The enum
+# type is whatever codegen assigned (``Severity``, ``Severity2``, ...), so it is
+# captured from the emitted source rather than hardcoded here.
 _SEVERITY_ENUM_DEFAULT_CLASSES = {
-    "LLMPipelineSchema",
-    "TextClassificationPipelineSchema",
+    "LLMPipelineSchema": "info",
+    "TextClassificationPipelineSchema": "info",
+    "TagPipelineSchema": "medium",
 }
 
 
@@ -37,17 +42,20 @@ def _patch_pipeline_type_defaults(source: str) -> str:
 
 
 def _patch_severity_enum_defaults(source: str) -> str:
-    """Replace string 'info' severity Field defaults with Severity.info enum instances.
+    """Replace string string severity Field defaults with enum instances.
 
     datamodel-codegen emits Field('info', ...) from the JSON schema default, but
     Pydantic v2 warns at serialization time when the stored value is a plain string
     rather than a Severity enum member.  This patch rewrites only the severity field
     inside each affected class so the fix survives future codegen runs.
     """
-    for cls_name in _SEVERITY_ENUM_DEFAULT_CLASSES:
+    for cls_name, member in _SEVERITY_ENUM_DEFAULT_CLASSES.items():
         # Match from the class definition up through the severity Field default string.
-        pattern = rf"(class {re.escape(cls_name)}\(.*?severity: Severity \| None = Field\(\n\s+)'info'(\s*,)"
-        replacement = rf"\1Severity.info\2"
+        pattern = (
+            rf"(class {re.escape(cls_name)}\(.*?severity: (Severity\d*) \| None = Field\(\n\s+)"
+            rf"'{re.escape(member)}'(\s*,)"
+        )
+        replacement = rf"\1\2.{member}\3"
         source = re.sub(pattern, replacement, source, flags=re.DOTALL)
     return source
 

{classifyre_cli-0.4.134 → classifyre_cli-0.4.135}/src/detectors/custom/detector.py

@@ -17,7 +17,12 @@ logger = logging.getLogger(__name__)
 
 
 class CustomDetector(BaseDetector):
-    """Schema-driven detector backed by a pluggable runner (GLINER2 | REGEX | LLM | transformer)."""
+    """Schema-driven detector backed by a pluggable runner.
+
+    GLINER2 | REGEX | LLM | transformer run over content. TAG does not: it
+    produces findings only from tags a CUSTOM connector attached to an asset,
+    which the pipeline applies through ``runner.tag_finding``.
+    """
 
     detector_type = "custom"
     detector_name = "custom"
@@ -47,5 +52,15 @@ class CustomDetector(BaseDetector):
             findings = findings[:max_findings]
         return findings
 
+    @property
+    def runner(self) -> BaseRunner:
+        """The pipeline strategy behind this detector.
+
+        Public because the tag pass has to ask what kind of runner this is: a
+        TAG detector never reaches ``detect()``, so recognising it is the only
+        way its findings get produced at all.
+        """
+        return self._runner
+
     def get_supported_content_types(self) -> list[str]:
         return self._runner.get_supported_content_types()

{classifyre_cli-0.4.134 → classifyre_cli-0.4.135}/src/detectors/custom/runners/__init__.py

@@ -26,6 +26,7 @@ from ._image_classification import ImageClassificationRunner
 from ._llm import LLMRunner
 from ._object_detection import ObjectDetectionRunner
 from ._regex import RegexRunner, _load_regex_engine
+from ._tag import TagRunner
 from ._text_classification import TextClassificationRunner, _chunk_text
 
 __all__ = [
@@ -39,6 +40,7 @@ __all__ = [
     "LLMRunner",
     "ObjectDetectionRunner",
     "RegexRunner",
+    "TagRunner",
     "TextClassificationRunner",
     "_apply_classification_validation",
     "_apply_entity_validation",

{classifyre_cli-0.4.134 → classifyre_cli-0.4.135}/src/detectors/custom/runners/_factory.py

@@ -8,6 +8,7 @@ from ....models.generated_detectors import (
     LLMPipelineSchema,
     ObjectDetectionPipelineSchema,
     RegexPipelineSchema,
+    TagPipelineSchema,
     TextClassificationPipelineSchema,
 )
 from ._base import BaseRunner
@@ -16,6 +17,7 @@ from ._image_classification import ImageClassificationRunner
 from ._llm import LLMRunner
 from ._object_detection import ObjectDetectionRunner
 from ._regex import RegexRunner
+from ._tag import TagRunner
 from ._text_classification import TextClassificationRunner
 
 
@@ -27,6 +29,7 @@ def create_runner(
         | TextClassificationPipelineSchema
         | ImageClassificationPipelineSchema
         | ObjectDetectionPipelineSchema
+        | TagPipelineSchema
     ),
     detector_key: str = "",
     detector_name: str = "",
@@ -42,5 +45,10 @@ def create_runner(
         return RegexRunner(schema, detector_key, detector_name)
     if isinstance(schema, LLMPipelineSchema):
         return LLMRunner(schema, detector_key, detector_name)
+    # Branched explicitly, not left to the fall-through below: a TAG schema that
+    # reached the GLiNER2 default would try to load a transformer model for a
+    # detector that is not supposed to run anything at all.
+    if isinstance(schema, TagPipelineSchema):
+        return TagRunner(schema, detector_key, detector_name)
     # GLiNER2PipelineSchema is the default / backward-compat path
     return GLiNER2Runner(schema, detector_key, detector_name)

{classifyre_cli-0.4.134 → classifyre_cli-0.4.135}/src/detectors/custom/runners/_llm.py

@@ -326,12 +326,21 @@ class LLMRunner(BaseRunner):
         )
 
         results: list[DetectionResult] = []
+        # Answers the threshold threw away. Recorded because discarding them
+        # silently is indistinguishable from the model never answering: at the
+        # schema-ish default of 0.55 every call logged "clean" and produced
+        # nothing, and the model had in fact answered every time — a free
+        # router model is simply systematically under-confident. The finding
+        # already carries the model's own confidence, so a threshold applied
+        # here only hides that the model was asked at all.
+        suppressed: list[tuple[str, float]] = []
         for entry in label_entries:
             label = str(entry.get("name", "")).strip()
             if not label:
                 continue
             confidence = float(entry.get("confidence", 1.0) or 0.0)
             if confidence < threshold:
+                suppressed.append((label, confidence))
                 continue
             severity = _resolve_pipeline_severity(label, schema.severity_map, default_severity)
             matched = str(entry.get("matched_content") or "").strip() or snippet[:320]
@@ -361,6 +370,19 @@ class LLMRunner(BaseRunner):
                 )
             )
 
+        if suppressed:
+            logger.warning(
+                "%s: confidence_threshold %.2f discarded %d model answer(s): %s%s. "
+                "The model answered — lower confidence_threshold (0 records every "
+                "answer with its confidence, to filter downstream) if this is not "
+                "what you meant.",
+                self._detector_key,
+                threshold,
+                len(suppressed),
+                ", ".join(f"{label}={score:.2f}" for label, score in suppressed[:5]),
+                " and more" if len(suppressed) > 5 else "",
+            )
+
         results.sort(key=lambda r: r.confidence, reverse=True)
         return results
 

classifyre_cli-0.4.135/src/detectors/custom/runners/_tag.py

@@ -0,0 +1,85 @@
+"""Tag pipeline runner — the one runner that never looks at content.
+
+A tag is an assertion, not a detection. The source system already knows that a
+table holds cardholder data or that a folder is under legal hold; running a
+classifier over the content to re-derive that fact can only lose information.
+So a TAG detector runs nothing. It exists to give the assertion a stable
+identity — a key, a label, a severity — and a CUSTOM connector notebook applies
+it by that key::
+
+    Asset(id="accounts", tags={"cardholder_data": "primary-account-numbers"})
+
+``detect()`` therefore returns nothing for any content it is handed. The finding
+is built by ``tag_finding()``, called from the detector pipeline once per tag the
+notebook attached to the asset.
+"""
+
+from __future__ import annotations
+
+from ....models.generated_detectors import (
+    PipelineResult,
+    Severity,
+    TagPipelineSchema,
+)
+from ....models.generated_single_asset_scan_results import DetectionResult
+from ._base import BaseRunner
+
+#: Matches the schema default. A tag has no confidence to derive a severity
+#: from, so an unreadable one falls back here rather than being guessed at.
+_DEFAULT_SEVERITY = Severity.medium
+
+
+class TagRunner(BaseRunner):
+    """Placeholder pipeline: produces findings only from notebook-supplied tags."""
+
+    def __init__(
+        self, schema: TagPipelineSchema, detector_key: str = "", detector_name: str = ""
+    ) -> None:
+        self.schema = schema
+        self._detector_key = detector_key
+        self._detector_name = detector_name
+        # The label is what every finding is called. Falling back to the
+        # detector name keeps a detector created without one readable rather
+        # than producing findings typed "tag:".
+        self.label = (schema.label or "").strip() or detector_name or detector_key or "tag"
+        self.severity = _coerce_severity(schema.severity)
+
+    def run(self, text: str) -> PipelineResult:
+        """No pipeline to run. Present only to satisfy the runner interface."""
+        return PipelineResult(metadata={"runner": "TAG"})
+
+    def detect(self, content: str | bytes, content_type: str) -> list[DetectionResult]:
+        """Never fires on content. A tag comes from the connector, not the text."""
+        return []
+
+    def get_supported_content_types(self) -> list[str]:
+        """No content type is supported, so the pipeline never schedules this."""
+        return []
+
+    def tag_finding(self, value: str) -> DetectionResult:
+        """One finding for one value the notebook asserted under this key."""
+        text = str(value).strip()
+        return self._make_result(
+            finding_type=f"tag:{self.label}",
+            category="CLASSIFICATION",
+            severity=self.severity,
+            # Asserted by the connector, not inferred from content: there is
+            # nothing here for a confidence score to express.
+            confidence=1.0,
+            matched_content=text,
+            location=None,
+            metadata={
+                "runner": "TAG",
+                "label": self.label,
+                "tag_key": self._detector_key,
+                "tag_value": text,
+            },
+        )
+
+
+def _coerce_severity(value: object) -> Severity:
+    if isinstance(value, Severity):
+        return value
+    if isinstance(value, str) and value in Severity.__members__:
+        return Severity(value)
+    return _DEFAULT_SEVERITY

{classifyre_cli-0.4.134 → classifyre_cli-0.4.135}/src/detectors/engine_version.py

@@ -30,7 +30,7 @@ DETECTOR_ENGINE_VERSION: Final[dict[str, int]] = {
     "YARA": 1,
     "BROKEN_LINKS": 1,
     "CODE_SECURITY": 1,
-    "CUSTOM": 1,
+    "CUSTOM": 2,
 }
 
 # Detectors whose verdict depends on state outside the asset, so identical

{classifyre_cli-0.4.134 → classifyre_cli-0.4.135}/src/graph/edges.py

@@ -33,7 +33,7 @@ from __future__ import annotations
 from collections.abc import Iterable, Sequence
 from dataclasses import dataclass, field
 from enum import StrEnum
-from typing import Any
+from typing import Any, ClassVar
 
 from ..utils.urn import Urn
 
@@ -171,8 +171,38 @@ class FieldMapping:
         }
 
 
+class _RefMeta(type):
+    """Turn a wrong constructor name into an instruction instead of a riddle.
+
+    ``Ref.id(...)`` is the natural guess and does not exist. The resulting
+    ``AttributeError`` was raised inside ``relationships()``, which the runner
+    caught as non-fatal -- so a notebook shipped 920 assets, zero edges, and a
+    COMPLETED run, with `type object 'Ref' has no attribute 'id'` visible only
+    in a Kubernetes job log. The visibility half of that is fixed elsewhere;
+    this half makes the message itself say what to write.
+    """
+
+    _SUGGESTIONS: ClassVar[dict[str, str]] = {
+        "id": "Ref.asset(<the id you gave Asset(id=...)>)",
+        "hash": "Ref.asset(<the id you gave Asset(id=...)>)",
+        "asset_id": "Ref.asset(<the id you gave Asset(id=...)>)",
+        "uri": "Ref.urn(<a urn like 'company://at/firmenbuchnummer/606601k'>)",
+        "url": "Ref.urn(<a urn like 'company://at/firmenbuchnummer/606601k'>)",
+        "external": "Ref.urn(<a urn naming the object in its own system>)",
+    }
+
+    def __getattr__(cls, name: str) -> Any:
+        suggestion = cls._SUGGESTIONS.get(name)
+        hint = f" Did you mean {suggestion}?" if suggestion else ""
+        raise AttributeError(
+            f"Ref has no '{name}'. An edge endpoint is one of "
+            f"Ref.asset(<asset id>), Ref.urn(<urn>) or Ref.finding(<finding id>)."
+            f"{hint}"
+        )
+
+
 @dataclass(frozen=True)
-class Ref:
+class Ref(metaclass=_RefMeta):
     """One end of an edge.
 
     ``asset`` names something this run produced, by its hash. ``urn`` names an

{classifyre_cli-0.4.134 → classifyre_cli-0.4.135}/src/main.py

@@ -175,12 +175,15 @@ async def _emit_relationships(source: Any, sink: Any, *, partial: bool = False)
     Best-effort by design — a connector that cannot describe its relationships
     should still deliver its assets — but *loudly* best-effort. Edge loss used
     to be invisible at three separate layers, so a scan could report success
-    having silently produced no lineage at all. Anything dropped is counted and
-    logged here, and the count travels with the run.
+    having silently produced no lineage at all. Anything lost is counted here
+    and handed to the sink, which carries it into the run record so the run
+    stops reporting an unqualified success (see ``set_relationship_losses``).
     """
     if not hasattr(sink, "emit_edges"):
         return
 
+    report = sink.relationship_report if hasattr(sink, "relationship_report") else None
+
     edges: list[Any] = []
     try:
         if hasattr(source, "drain_edges"):
@@ -193,7 +196,21 @@ async def _emit_relationships(source: Any, sink: Any, *, partial: bool = False)
             if collected:
                 edges.extend(collected)
     except Exception as collect_error:
+        # The connector's relationship code raised. How many edges that cost is
+        # unknowable — it never got to say — so this is counted as one failed
+        # relationship pass rather than as N lost edges.
         logger.warning("Could not collect relationships (non-fatal): %s", collect_error)
+        if report is not None:
+            report.record_failure(
+                f"{type(collect_error).__name__}: {collect_error}",
+            )
+
+    # A connector that declares relationships() but produced nothing is not the
+    # same as one that has no lineage to declare, and the difference is exactly
+    # the failure mode this reporting exists for: an exception inside
+    # relationships() used to leave a green run with zero edges.
+    if report is not None and not edges and _declares_relationships(source):
+        report.record_empty()
 
     if not edges:
         return
@@ -206,9 +223,20 @@ async def _emit_relationships(source: Any, sink: Any, *, partial: bool = False)
             len(edges),
             emit_error,
         )
+        if report is not None:
+            report.record_lost(
+                len(edges),
+                f"{type(emit_error).__name__}: {emit_error}",
+            )
         return
 
-    unresolved = (result or {}).get("dropped", 0) if isinstance(result, dict) else 0
+    tally = result if isinstance(result, dict) else {}
+    unresolved = tally.get("dropped", 0) or 0
+    if report is not None:
+        report.record_emitted(
+            emitted=len(edges) - unresolved,
+            dropped=unresolved,
+        )
     logger.info(
         "Emitted %d relationship edge(s)%s%s",
         len(edges),
@@ -217,6 +245,17 @@ async def _emit_relationships(source: Any, sink: Any, *, partial: bool = False)
     )
 
 
+def _declares_relationships(source: Any) -> bool:
+    """Whether this connector claims to describe relationships at all."""
+    declares = getattr(source, "declares_relationships", None)
+    if callable(declares):
+        try:
+            return bool(declares())
+        except Exception:  # pragma: no cover - a probe must never fail a scan
+            return False
+    return hasattr(source, "collect_relationships")
+
+
 async def run_command_async(args: argparse.Namespace, recipe: dict[str, Any]) -> None:
     """Initialize the source and execute the specified command."""
     runner_id = args.runner_id or os.environ.get("RUNNER_ID") or "local-run"

{classifyre_cli-0.4.134 → classifyre_cli-0.4.135}/src/models/generated_detectors.py

@@ -932,6 +932,40 @@ class PipelineSeverityRule(BaseModel):
     severity: Severity
 
 
+class AssetKind(StrEnum):
+    record = 'record'
+    document = 'document'
+    page = 'page'
+    file = 'file'
+    table = 'table'
+
+
+class DetectorScope(BaseModel):
+    """
+    Restricts which of a source's assets this detector runs on.
+
+    A custom detector is attached to a SOURCE, so without this it runs on every asset that source produces. For an expensive engine that is not a tuning problem but a design problem: attaching an LLM detector to a documents source meant one model call per filed PDF and per raw XML blob — 3 to 25 seconds each, on inputs the model had no business reading — and the run spent its entire life in the detector pool. The only workaround was splitting one source in two, which is a defensible architecture but was forced rather than chosen.
+
+    Every field is optional and they AND together; an empty scope runs everywhere, which is the previous behaviour.
+    """
+
+    model_config = ConfigDict(
+        extra='forbid',
+    )
+    asset_kinds: list[AssetKind] | None = Field(
+        None,
+        description='Catalog kinds this detector applies to. ["record"] is the natural expression of "run on the derived summaries, not on the source documents they came from".',
+    )
+    content_types: list[str] | None = Field(
+        None,
+        description="MIME types or prefixes (application/pdf, text/). Narrower than the engine's own supported types, never wider: a detector still never sees content its runner cannot read.",
+    )
+    metadata: dict[str, Any] | None = Field(
+        None,
+        description='Asset-metadata equality predicate, e.g. {"doc_type": "jab"}. Every named key must be present on the asset and equal (compared as strings, so 4 and "4" match). A key the asset does not carry excludes it — an absent field is not a match.',
+    )
+
+
 class Type1(StrEnum):
     GLINER2 = 'GLINER2'
 
@@ -940,6 +974,10 @@ class GLiNER2PipelineSchema(BaseModel):
     model_config = ConfigDict(
         extra='forbid',
     )
+    scope: DetectorScope | None = Field(
+        None,
+        description='Restrict this detector to part of a source (asset kind, content type, or an asset-metadata predicate). Null runs it on everything the source produces.',
+    )
     type: Literal['GLINER2'] = 'GLINER2'
     entities: dict[str, PipelineEntityDefinition] | None = None
     classification: dict[str, PipelineClassificationDefinition] | None = None
@@ -955,6 +993,10 @@ class RegexPipelineSchema(BaseModel):
     model_config = ConfigDict(
         extra='forbid',
     )
+    scope: DetectorScope | None = Field(
+        None,
+        description='Restrict this detector to part of a source (asset kind, content type, or an asset-metadata predicate). Null runs it on everything the source produces.',
+    )
     type: Literal['REGEX'] = 'REGEX'
     patterns: dict[str, RegexPatternDefinition] | None = None
     validation: PipelineValidationConfig | None = None
@@ -1059,6 +1101,10 @@ class LLMPipelineSchema(BaseModel):
     model_config = ConfigDict(
         extra='forbid',
     )
+    scope: DetectorScope | None = Field(
+        None,
+        description='Restrict this detector to part of a source (asset kind, content type, or an asset-metadata predicate). Null runs it on everything the source produces.',
+    )
     type: Literal['LLM'] = 'LLM'
     system_prompt: str = Field(
         ...,
@@ -1095,7 +1141,7 @@ class LLMPipelineSchema(BaseModel):
     )
     confidence_threshold: float | None = Field(
         0.5,
-        description='Minimum model confidence to report a label as a finding (0-1).',
+        description='Minimum model confidence to report a label as a finding (0-1). Applied BEFORE the finding is recorded, so anything below it leaves no trace but a count in the run log — and a systematically under-confident model (free routers are) then looks like a model that never answered. The finding already carries the confidence, so 0 records every answer and lets you filter downstream.',
         ge=0.0,
         le=1.0,
     )
@@ -1155,6 +1201,10 @@ class TextClassificationPipelineSchema(BaseModel):
     model_config = ConfigDict(
         extra='forbid',
     )
+    scope: DetectorScope | None = Field(
+        None,
+        description='Restrict this detector to part of a source (asset kind, content type, or an asset-metadata predicate). Null runs it on everything the source produces.',
+    )
     type: Literal['TEXT_CLASSIFICATION']
     model: str = Field(
         ...,
@@ -1225,6 +1275,10 @@ class ImageClassificationPipelineSchema(BaseModel):
     model_config = ConfigDict(
         extra='forbid',
     )
+    scope: DetectorScope | None = Field(
+        None,
+        description='Restrict this detector to part of a source (asset kind, content type, or an asset-metadata predicate). Null runs it on everything the source produces.',
+    )
     type: Literal['IMAGE_CLASSIFICATION']
     model: str | None = Field(
         None,
@@ -1277,6 +1331,10 @@ class ObjectDetectionPipelineSchema(BaseModel):
     model_config = ConfigDict(
         extra='forbid',
     )
+    scope: DetectorScope | None = Field(
+        None,
+        description='Restrict this detector to part of a source (asset kind, content type, or an asset-metadata predicate). Null runs it on everything the source produces.',
+    )
     type: Literal['OBJECT_DETECTION']
     model: str = Field(
         ...,
@@ -1313,6 +1371,45 @@ class ObjectDetectionPipelineSchema(BaseModel):
     )
 
 
+class Type8(StrEnum):
+    TAG = 'TAG'
+
+
+class Severity2(StrEnum):
+    """
+    Severity assigned to every finding this detector produces. There is no confidence to derive it from: a tag is asserted, not inferred.
+    """
+
+    critical = 'critical'
+    high = 'high'
+    medium = 'medium'
+    low = 'low'
+    info = 'info'
+
+
+class TagPipelineSchema(BaseModel):
+    """
+    A placeholder detector that runs no classification and never reads content. It exists only to give a manual assertion a stable identity. A CUSTOM connector notebook applies it by the detector's key: Asset(tags={"<detector key>": "<value>"}). Not selectable in a source's detector list.
+    """
+
+    model_config = ConfigDict(
+        extra='forbid',
+    )
+    scope: DetectorScope | None = Field(
+        None,
+        description='Restrict this detector to part of a source (asset kind, content type, or an asset-metadata predicate). Null runs it on everything the source produces.',
+    )
+    type: Literal['TAG'] = 'TAG'
+    label: str | None = Field(
+        None,
+        description="Label carried by every finding this detector produces (finding_type is 'tag:<label>'). Defaults to the detector's name when omitted.",
+    )
+    severity: Severity2 | None = Field(
+        Severity2.medium,
+        description='Severity assigned to every finding this detector produces. There is no confidence to derive it from: a tag is asserted, not inferred.',
+    )
+
+
 class CustomDetectorConfig(DetectorConfig):
     """
     Configuration for user-defined detector execution
@@ -1338,6 +1435,7 @@ class CustomDetectorConfig(DetectorConfig):
         | TextClassificationPipelineSchema
         | ImageClassificationPipelineSchema
         | ObjectDetectionPipelineSchema
+        | TagPipelineSchema
         | None
     ) = Field(None, discriminator='type', title='AnyPipelineSchema')
     max_findings: int | None = Field(