fix(asr): normalize origin rejection statuses

cai

2026-08-11 db6463d9f98f740d4e8b6d3a0a25b65688196321

 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(),