From db6463d9f98f740d4e8b6d3a0a25b65688196321 Mon Sep 17 00:00:00 2001
From: cai <cai@nbcai.cc>
Date: Tue, 11 Aug 2026 18:50:21 +0800
Subject: [PATCH] fix(asr): normalize origin rejection statuses

---
 src/asr_realtime.rs |   91 +++++++++++++++++++++++++++++++++++++++++++--
 1 files changed, 87 insertions(+), 4 deletions(-)

diff --git a/src/asr_realtime.rs b/src/asr_realtime.rs
index c1afd25..a7ff7f7 100644
--- a/src/asr_realtime.rs
+++ b/src/asr_realtime.rs
@@ -37,6 +37,39 @@
 }
 
 impl AudioIngressMetadata {
+    pub(crate) const ORIGIN_STATUSES: [&'static str; 8] = [
+        "controlled_fixture_bound",
+        "ordinary_mic_absent",
+        "participant_attributes_absent",
+        "participant_attributes_invalid",
+        "sequence_absent",
+        "sequence_replayed_or_regressed",
+        "wrong_participant_or_track",
+        "origin_unprovable",
+    ];
+
+    pub(crate) fn origin_status(attributes: &HashMap<String, String>) -> &'static str {
+        let source = attributes.get("inputSourceCategory").map(String::as_str);
+        let sequence = attributes.get("clientFixtureSequence").map(String::as_str);
+        match (source, sequence) {
+            (None, None) => "ordinary_mic_absent",
+            (Some("controlled_fixture"), Some(sequence)) if valid_sequence(sequence) => {
+                "controlled_fixture_bound"
+            }
+            (Some("controlled_fixture"), None) => "sequence_absent",
+            (Some("controlled_fixture"), Some(_)) => "participant_attributes_invalid",
+            (Some(_), _) | (None, Some(_)) => "participant_attributes_invalid",
+        }
+    }
+
+    pub(crate) fn rejection_status(reason: &str) -> &'static str {
+        match reason {
+            "incomplete_metadata" => "participant_attributes_absent",
+            "invalid_source_or_sequence" => "participant_attributes_invalid",
+            _ => "origin_unprovable",
+        }
+    }
+
     pub(crate) fn from_participant(
         attributes: &HashMap<String, String>,
     ) -> Result<Option<Self>, &'static str> {
@@ -106,9 +139,7 @@
         F: FnOnce() -> HashMap<String, String>,
     {
         let metadata = AudioIngressMetadata::from_participant(&read_attributes())
-            .map_err(|reason| anyhow!(reason))
-            .ok()
-            .flatten();
+            .map_err(|reason| anyhow!(reason))?;
         Self::start(
             http,
             config,
@@ -352,7 +383,7 @@
     samples: Vec<i16>,
 }
 
-fn session_start_line(
+pub(crate) fn session_start_line(
     call_id: &str,
     trace_id: &str,
     turn_id: &str,
@@ -375,6 +406,10 @@
         line["inputSourceCategory"] = json!(metadata.input_source_category);
         line["clientFixtureSequence"] = json!(metadata.client_fixture_sequence);
     }
+    line["audioIngressOriginStatus"] = json!(match ingress_metadata {
+        Some(_) => "controlled_fixture_bound",
+        None => "ordinary_mic_absent",
+    });
     encode_line(line)
 }
 
@@ -485,6 +520,7 @@
         assert_eq!("pcm_s16le", value["audio"]["format"]);
         assert_eq!(16000, value["audio"]["sampleRate"]);
         assert_eq!(1, value["audio"]["channels"]);
+        assert_eq!("ordinary_mic_absent", value["audioIngressOriginStatus"]);
     }
 
     #[test]
@@ -507,6 +543,10 @@
             }),
             metadata
         );
+        assert_eq!(
+            "controlled_fixture_bound",
+            AudioIngressMetadata::origin_status(&attributes)
+        );
 
         attributes.insert(
             "clientFixtureSequence".to_string(),
@@ -520,6 +560,44 @@
             Ok(None),
             AudioIngressMetadata::from_participant(&HashMap::new())
         );
+        attributes.remove("clientFixtureSequence");
+        assert_eq!(
+            "sequence_absent",
+            AudioIngressMetadata::origin_status(&attributes)
+        );
+        attributes.insert(
+            "clientFixtureSequence".to_string(),
+            "bad sequence".to_string(),
+        );
+        assert_eq!(
+            "participant_attributes_invalid",
+            AudioIngressMetadata::origin_status(&attributes)
+        );
+        assert_eq!(
+            "ordinary_mic_absent",
+            AudioIngressMetadata::origin_status(&HashMap::new())
+        );
+        assert_eq!(
+            "participant_attributes_absent",
+            AudioIngressMetadata::rejection_status("incomplete_metadata")
+        );
+        assert_eq!(
+            "participant_attributes_invalid",
+            AudioIngressMetadata::rejection_status("invalid_source_or_sequence")
+        );
+        assert_eq!(
+            "sequence_replayed_or_regressed",
+            AudioIngressMetadata::rejection_status("sequence_replayed")
+        );
+        assert_eq!(
+            "wrong_participant_or_track",
+            AudioIngressMetadata::rejection_status("wrong_participant")
+        );
+        assert_eq!(
+            "origin_unprovable",
+            AudioIngressMetadata::rejection_status("unknown")
+        );
+        assert_eq!(8, AudioIngressMetadata::ORIGIN_STATUSES.len());
     }
 
     #[test]
@@ -534,6 +612,7 @@
         )
         .expect("absent json");
         assert!(absent.get("inputSourceCategory").is_none());
+        assert_eq!("ordinary_mic_absent", absent["audioIngressOriginStatus"]);
         let with_metadata = serde_json::from_slice::<serde_json::Value>(
             &session_start_line(
                 "call-001",
@@ -547,6 +626,10 @@
         .expect("bound json");
         assert_eq!("controlled_fixture", with_metadata["inputSourceCategory"]);
         assert_eq!("fixture-01", with_metadata["clientFixtureSequence"]);
+        assert_eq!(
+            "controlled_fixture_bound",
+            with_metadata["audioIngressOriginStatus"]
+        );
         let next = AudioIngressMetadata {
             input_source_category: "controlled_fixture".to_string(),
             client_fixture_sequence: "fixture-02".to_string(),

--
Gitblit v1.9.3