Struct DialogueTurn 

pub struct DialogueTurn {
    pub text: String,
    pub speaker: String,
    pub participant_type: ParticipantType,
    pub speech_act: Option<SpeechActType>,
    pub is_aside: bool,
    pub triggered_cutoff: bool,
    pub turn_number: usize,
    pub addressee: Option<String>,
    pub language: Option<String>,
    pub start: usize,
    pub end: usize,
}

A single turn in a dialogue.

Why Turn-Level Metadata?

Written text is speaker-agnostic. Dialogue requires tracking:

• Who said this?
• Who were they talking to?
• Was this meant to be heard by the agent?
• Did it trigger an unwanted agent response?

Example

use anno::discourse::dialogue::{DialogueTurn, SpeechActType, ParticipantType};

// A human says "oui" as a continuer
let turn = DialogueTurn::new("oui", "EMM")
    .with_participant_type(ParticipantType::Human)
    .with_speech_act(SpeechActType::Continuer)
    .with_triggered_cutoff(true);

assert!(turn.is_response_token());
assert!(turn.triggered_cutoff);

Fields

text: String

The utterance text.

speaker: String

Speaker identifier (e.g., “EMM”, “GPT”, “TOM”).

participant_type: ParticipantType

Type of participant (human or agent).

speech_act: Option<SpeechActType>

Pragmatic function of this turn.

is_aside: bool

Is this an aside (directed away from the agent)?

Aside sequences are contributions designed to exclude the agent:

• Whispered to co-participants
• Gestured/mouthed rather than spoken
• Explicitly directed at another human

triggered_cutoff: bool

Did this turn trigger an agent interruption/cutoff?

Response tokens often trigger unwanted agent responses because VAD detects them as speech requiring a response.

turn_number: usize

Turn number in the dialogue (0-indexed).

addressee: Option<String>

Who this turn is addressed to (if known).

language: Option<String>

Language code (e.g., “fr”, “en”).

start: usize

Character offset in the full dialogue transcript.

end: usize

End character offset.

Implementations

impl DialogueTurn

pub fn new(text: impl Into<String>, speaker: impl Into<String>) -> DialogueTurn

Create a new dialogue turn.

pub fn with_participant_type(self, pt: ParticipantType) -> DialogueTurn

Set participant type.

pub fn with_speech_act(self, act: SpeechActType) -> DialogueTurn

Set speech act type.

pub fn as_aside(self, is_aside: bool) -> DialogueTurn

Mark as aside (not directed at agent).

pub fn with_triggered_cutoff(self, triggered: bool) -> DialogueTurn

Mark whether this triggered an agent cutoff.

pub fn with_turn_number(self, n: usize) -> DialogueTurn

Set turn number.

pub fn with_addressee(self, addr: impl Into<String>) -> DialogueTurn

Set addressee.

pub fn with_language(self, lang: impl Into<String>) -> DialogueTurn

Set language.

pub fn with_span(self, start: usize, end: usize) -> DialogueTurn

Set character span.

pub fn is_response_token(&self) -> bool

Is this a response token?

pub fn is_human(&self) -> bool

Is this from a human participant?

pub fn is_agent(&self) -> bool

Is this from an agent participant?

Trait Implementations

impl Clone for DialogueTurn

fn clone(&self) -> DialogueTurn

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DialogueTurn

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DialogueTurn

fn deserialize<__D>( __deserializer: __D, ) -> Result<DialogueTurn, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for DialogueTurn

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.