feat(asr): propagate participant language per session

cai

2026-08-22 fe5c23af3c46d6a6168d9b77bd703065aa65cbc5

 src/asr_realtime.rs

@@ -34,6 +34,7 @@
pub(crate) struct AudioIngressMetadata {
    pub(crate) input_source_category: String,
    pub(crate) client_fixture_sequence: String,
    pub(crate) language: Option<String>,
}

impl AudioIngressMetadata {
@@ -70,6 +71,18 @@
        }
    }

    pub(crate) fn rejected_origin_status(
        reason: &str,
        attributes: &HashMap<String, String>,
    ) -> &'static str {
        let status = Self::origin_status(attributes);
        if status == "sequence_absent" {
            status
        } else {
            Self::rejection_status(reason)
        }
    }

    pub(crate) fn from_participant(
        attributes: &HashMap<String, String>,
    ) -> Result<Option<Self>, &'static str> {
@@ -78,9 +91,16 @@
        match (source, sequence) {
            (None, None) => Ok(None),
            (Some("controlled_fixture"), Some(sequence)) if valid_sequence(sequence) => {
                let language = attributes.get("language").map(String::as_str);
                if let Some(language) = language {
                    if !valid_language(language) {
                        return Err("invalid_language");
                    }
                }
                Ok(Some(Self {
                    input_source_category: "controlled_fixture".to_string(),
                    client_fixture_sequence: sequence.to_string(),
                    language: language.map(str::to_string),
                }))
            }
            (Some(_), _) => Err("invalid_source_or_sequence"),
@@ -95,6 +115,10 @@
        && value
            .chars()
            .all(|ch| ch.is_ascii_alphanumeric() || matches!(ch, '-' | '_' | '.'))
}

fn valid_language(value: &str) -> bool {
    matches!(value, "ja-JP" | "zh-CN")
}

impl RealtimeAsrConfig {
@@ -405,6 +429,9 @@
    if let Some(metadata) = ingress_metadata {
        line["inputSourceCategory"] = json!(metadata.input_source_category);
        line["clientFixtureSequence"] = json!(metadata.client_fixture_sequence);
        if let Some(language) = metadata.language.as_deref() {
            line["language"] = json!(language);
        }
    }
    line["audioIngressOriginStatus"] = json!(match ingress_metadata {
        Some(_) => "controlled_fixture_bound",
@@ -534,12 +561,14 @@
            "clientFixtureSequence".to_string(),
            "fixture-01".to_string(),
        );
        attributes.insert("language".to_string(), "ja-JP".to_string());
        let metadata =
            AudioIngressMetadata::from_participant(&attributes).expect("valid attributes");
        assert_eq!(
            Some(AudioIngressMetadata {
                input_source_category: "controlled_fixture".to_string(),
                client_fixture_sequence: "fixture-01".to_string(),
                language: Some("ja-JP".to_string()),
            }),
            metadata
        );
@@ -577,6 +606,16 @@
            "ordinary_mic_absent",
            AudioIngressMetadata::origin_status(&HashMap::new())
        );
        attributes.insert(
            "clientFixtureSequence".to_string(),
            "fixture-01".to_string(),
        );
        attributes.insert("language".to_string(), "ja-jp".to_string());
        assert_eq!(
            Err("invalid_language"),
            AudioIngressMetadata::from_participant(&attributes)
        );
        attributes.insert("language".to_string(), "ja-JP".to_string());
        assert_eq!(
            "participant_attributes_absent",
            AudioIngressMetadata::rejection_status("incomplete_metadata")
@@ -597,6 +636,14 @@
            "origin_unprovable",
            AudioIngressMetadata::rejection_status("unknown")
        );
        let missing_sequence = HashMap::from([(
            "inputSourceCategory".to_string(),
            "controlled_fixture".to_string(),
        )]);
        assert_eq!(
            "sequence_absent",
            AudioIngressMetadata::rejected_origin_status("incomplete_metadata", &missing_sequence)
        );
        assert_eq!(8, AudioIngressMetadata::ORIGIN_STATUSES.len());
    }

@@ -605,6 +652,7 @@
        let bound = AudioIngressMetadata {
            input_source_category: "controlled_fixture".to_string(),
            client_fixture_sequence: "fixture-01".to_string(),
            language: Some("ja-JP".to_string()),
        };
        let absent = serde_json::from_slice::<serde_json::Value>(
            &session_start_line("call-001", "trace-001", "turn-0001", "nonce-001", None)
@@ -626,6 +674,7 @@
        .expect("bound json");
        assert_eq!("controlled_fixture", with_metadata["inputSourceCategory"]);
        assert_eq!("fixture-01", with_metadata["clientFixtureSequence"]);
        assert_eq!("ja-JP", with_metadata["language"]);
        assert_eq!(
            "controlled_fixture_bound",
            with_metadata["audioIngressOriginStatus"]
@@ -633,6 +682,7 @@
        let next = AudioIngressMetadata {
            input_source_category: "controlled_fixture".to_string(),
            client_fixture_sequence: "fixture-02".to_string(),
            language: Some("zh-CN".to_string()),
        };
        let next_line = session_start_line(
            "call-001",
@@ -644,6 +694,7 @@
        .expect("next bound session line");
        let next_value: serde_json::Value = serde_json::from_slice(&next_line).expect("next json");
        assert_eq!("fixture-02", next_value["clientFixtureSequence"]);
        assert_eq!("zh-CN", next_value["language"]);
        assert_ne!(
            with_metadata["clientFixtureSequence"],
            next_value["clientFixtureSequence"]