Custom patterns + configurable guardrails

crates/nvisy-engine/src/analyzer/audio.rs

@@ -16,60 +16,34 @@
 //! [`AnalyzerParams`]: nvisy_schema::plan::AnalyzerParams
 
 use elide::detection::Analyzer;
+use elide_core::Error;
 use elide_core::modality::audio::Audio;
-use elide_core::{Error, ErrorKind};
-#[cfg(feature = "test-utils")]
-use elide_stt::{MockBackend as MockSttBackend, SttEnricher};
 use nvisy_core::ner::NerConfig;
-use nvisy_schema::plan::{AnalyzerParams, SttBackendParams, SttEnricherParams};
+use nvisy_schema::plan::AnalyzerParams;
 
-use super::common::{attach_dedup, attach_pattern};
-use super::ner::attach_ner_lineup;
+use super::PatternGuardrails;
+use super::enricher::attach_stt;
+use super::layer::attach_dedup;
+use super::recognizer::{attach_ner_lineup, attach_pattern};
 
 /// Compile `spec` into an audio-modality [`Analyzer`].
-pub(super) fn compile(spec: &AnalyzerParams, ner: &NerConfig) -> Result<Analyzer<Audio>, Error> {
+pub(super) fn compile(
+    spec: &AnalyzerParams,
+    ner: &NerConfig,
+    guardrails: &PatternGuardrails,
+) -> Result<Analyzer<Audio>, Error> {
     let mut analyzer = Analyzer::<Audio>::new();
 
     if let Some(stt) = &spec.enrichers.stt {
         analyzer = attach_stt(analyzer, stt)?;
     }
 
     if let Some(pattern) = &spec.recognizers.pattern {
-        analyzer = attach_pattern(analyzer, pattern)?;
+        analyzer = attach_pattern(analyzer, pattern, guardrails)?;
     }
     if spec.recognizers.ner {
         analyzer = attach_ner_lineup(analyzer, ner)?;
     }
 
     Ok(attach_dedup(analyzer, &spec.deduplication))
 }
-
-/// Attach an [`SttEnricher`] for the audio modality. The
-/// deployment's `Bento` backend returns a clean "not wired yet"
-/// error until `elide-bento` ships a `BentoStt` client;
-/// unknown variants surface as Validation.
-///
-/// [`SttEnricher`]: elide_stt::SttEnricher
-fn attach_stt(
-    analyzer: Analyzer<Audio>,
-    spec: &SttEnricherParams,
-) -> Result<Analyzer<Audio>, Error> {
-    #[cfg(not(feature = "test-utils"))]
-    let _ = analyzer;
-    match &spec.backend {
-        SttBackendParams::Bento { .. } => Err(Error::new(
-            ErrorKind::Validation,
-            "analyzer compile: BentoML STT backend needs an elide-bento `BentoStt` \
-             client; not wired into the compile surface yet",
-        )),
-        #[cfg(feature = "test-utils")]
-        SttBackendParams::Mock => Ok(analyzer.with_enricher(SttEnricher::new(MockSttBackend))),
-        // `SttBackendParams` is `#[non_exhaustive]`. Unknown
-        // variants surface as Validation.
-        _ => Err(Error::new(
-            ErrorKind::Validation,
-            "analyzer compile: STT enricher uses a backend kind this engine binary \
-             doesn't understand; upgrade the engine or downgrade the config",
-        )),
-    }
-}

crates/nvisy-engine/src/analyzer/enricher/language.rs

@@ -0,0 +1,29 @@
+//! Attach the lingua language-detection [`Enricher<Text>`].
+//!
+//! Text-modality only — writes the detected language into the
+//! per-request recognizer context, so pattern/NER/LLM downstream
+//! see what it wrote.
+//!
+//! [`Enricher<Text>`]: elide_core::recognition::Enricher
+
+use elide::detection::Analyzer;
+use elide::enrichment::lingua::LinguaEnricher;
+use elide_core::modality::text::Text;
+use nvisy_schema::plan::LanguageEnricherParams;
+
+/// Attach the lingua language-detection enricher built from `spec`.
+///
+/// An empty `candidates` list yields the unrestricted detector
+/// (every language lingua was compiled with); a non-empty list
+/// scopes detection to that pool.
+pub(in crate::analyzer) fn attach(
+    analyzer: Analyzer<Text>,
+    spec: &LanguageEnricherParams,
+) -> Analyzer<Text> {
+    let enricher = if spec.candidates.is_empty() {
+        LinguaEnricher::unrestricted()
+    } else {
+        LinguaEnricher::with_candidates(spec.candidates.iter().cloned())
+    };
+    analyzer.with_enricher(enricher)
+}

crates/nvisy-engine/src/analyzer/enricher/mod.rs

@@ -0,0 +1,19 @@
+//! Per-enricher compile helpers: `language`, `ocr`, `stt`.
+//!
+//! Symmetric with [`super::recognizer`]. Enrichers run before
+//! recognition and stamp side-channel data (language hint,
+//! OCR'd text layout, audio transcript segments) onto the
+//! per-request context so downstream recognizers pick it up
+//! transparently.
+//!
+//! Every enricher is at-most-one per analyzer; the caller-facing
+//! spec is the corresponding slot on
+//! [`nvisy_schema::plan::EnricherParams`].
+
+mod language;
+mod ocr;
+mod stt;
+
+pub(super) use self::language::attach as attach_language;
+pub(super) use self::ocr::attach as attach_ocr;
+pub(super) use self::stt::attach as attach_stt;