Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust
11.1 KB
Raw Blame
//! V3 transcript reconciliation across interleaved speakers, reconnects, and turn boundaries.

use super::*;
use codex_protocol::protocol::RealtimeTranscriptDone;
use pretty_assertions::assert_eq;

fn events(transcript_state: RealtimeTranscriptState) -> RealtimeWebsocketEvents {
    let (_, rx_message) = async_channel::unbounded();
    RealtimeWebsocketEvents {
        rx_message,
        pending_events: Arc::new(Mutex::new(VecDeque::new())),
        transcript_state,
        event_parser: RealtimeEventParser::FramelessBidi,
        is_closed: Arc::new(AtomicBool::new(false)),
    }
}

fn entry(role: &str, text: &str) -> RealtimeTranscriptEntry {
    RealtimeTranscriptEntry {
        role: role.to_string(),
        text: text.to_string(),
    }
}

async fn observe(events: &RealtimeWebsocketEvents, mut event: RealtimeEvent) {
    let original = event.clone();
    events
        .update_active_transcript(&mut event, /*frame*/ None)
        .await;
    assert_eq!(
        event, original,
        "live transcript events must pass through unchanged"
    );
}

#[tokio::test]
async fn interleaved_transcripts_reconcile_across_reconnect_in_either_completion_order() {
    for assistant_finishes_first in [false, true] {
        let state = RealtimeTranscriptState::default();
        let first = events(state.clone());
        for event in [
            RealtimeEvent::InputTranscriptDelta(RealtimeTranscriptDelta {
                delta: "What can ".into(),
            }),
            RealtimeEvent::OutputTranscriptDelta(RealtimeTranscriptDelta {
                delta: "A bunch ".into(),
            }),
            RealtimeEvent::InputTranscriptDelta(RealtimeTranscriptDelta {
                delta: "you do?".into(),
            }),
            RealtimeEvent::OutputTranscriptDelta(RealtimeTranscriptDelta {
                delta: "of stuff".into(),
            }),
        ] {
            observe(&first, event).await;
        }
        let reconnected = events(state);
        let user = RealtimeEvent::InputTranscriptDone(RealtimeTranscriptDone {
            text: "What can you do?".into(),
        });
        let assistant = RealtimeEvent::OutputTranscriptDone(RealtimeTranscriptDone {
            text: "A bunch of stuff, including coding.".into(),
        });
        let finals = if assistant_finishes_first {
            [assistant, user]
        } else {
            [user, assistant]
        };
        for event in finals {
            observe(&reconnected, event).await;
        }
        assert_eq!(
            reconnected.take_transcript_tail().await,
            vec![
                entry("user", "What can you do?"),
                entry("assistant", "A bunch of stuff, including coding."),
            ]
        );
        assert_eq!(reconnected.take_transcript_tail().await, vec![]);
    }
}

#[tokio::test]
async fn completed_utterances_keep_repeated_speech_and_final_only_turns_distinct() {
    let events = events(RealtimeTranscriptState::default());
    for role in ["user", "assistant"] {
        for with_delta in [true, true, false] {
            if with_delta {
                let delta = RealtimeTranscriptDelta {
                    delta: "Again".into(),
                };
                observe(
                    &events,
                    if role == "user" {
                        RealtimeEvent::InputTranscriptDelta(delta)
                    } else {
                        RealtimeEvent::OutputTranscriptDelta(delta)
                    },
                )
                .await;
            }
            let done = RealtimeTranscriptDone {
                text: "Again.".into(),
            };
            observe(
                &events,
                if role == "user" {
                    RealtimeEvent::InputTranscriptDone(done)
                } else {
                    RealtimeEvent::OutputTranscriptDone(done)
                },
            )
            .await;
            // An empty delta must not reopen the utterance we just completed.
            let empty = RealtimeTranscriptDelta {
                delta: String::new(),
            };
            observe(
                &events,
                if role == "user" {
                    RealtimeEvent::InputTranscriptDelta(empty)
                } else {
                    RealtimeEvent::OutputTranscriptDelta(empty)
                },
            )
            .await;
        }
        assert_eq!(
            events.take_transcript_tail().await,
            vec![entry(role, "Again."); 3]
        );
    }
}

#[tokio::test]
async fn transcript_budget_uses_frame_recency_without_reordering_speakers() {
    use serde_json::json;

    let old_user = "u".repeat(4000);
    let assistant = "a".repeat(4000);
    let newest_user = "n".repeat(211);
    let current_user = "u".repeat(4160);
    let same_frame_user = "n".repeat(22);
    let unicode_user = "é".repeat(2000);
    let oversized_user = "u".repeat(MAX_ACTIVE_TRANSCRIPT_BYTES);
    let extended_assistant = format!("{assistant}{newest_user}!");
    for (frames, final_assistant, expected) in [
        (
            vec![
                ("user", old_user.as_str(), Some(0)),
                ("assistant", assistant.as_str(), Some(200)),
                ("user", newest_user.as_str(), Some(400)),
                // Commit eviction before the delayed final arrives.
                ("user", "", Some(600)),
            ],
            // A late final must keep the evicted assistant's old raw-frame age.
            Some(assistant.as_str()),
            vec![entry("user", &format!("{old_user}{newest_user}"))],
        ),
        (
            vec![
                ("assistant", assistant.as_str(), Some(0)),
                ("user", current_user.as_str(), Some(200)),
                // The first event already exceeds the budget, before output updates its age.
                ("user", same_frame_user.as_str(), Some(400)),
                // Same-frame input is emitted first; output must not become newer.
                ("assistant", "bbbbbbbbbbbbbbbbbbbb", Some(400)),
            ],
            None,
            vec![
                entry("assistant", &format!("{assistant}bbbbbbbbbbbbbbbbbbbb")),
                entry("user", &format!("…{}{same_frame_user}", "u".repeat(4128))),
            ],
        ),
        (
            vec![
                ("user", old_user.as_str(), Some(0)),
                ("assistant", assistant.as_str(), Some(200)),
                ("user", newest_user.as_str(), Some(400)),
                ("assistant", "b", Some(400)),
            ],
            None,
            vec![
                entry("user", &format!("…{}{newest_user}", "u".repeat(3958))),
                entry("assistant", &format!("{assistant}b")),
            ],
        ),
        (
            vec![
                ("user", old_user.as_str(), Some(0)),
                ("assistant", assistant.as_str(), Some(200)),
                // Reversing the same-frame events must retain the same suffixes.
                ("assistant", "b", Some(400)),
                ("user", newest_user.as_str(), Some(400)),
                // Advancing the frame also commits eviction before the tail is taken.
                ("user", "", Some(600)),
            ],
            None,
            vec![
                entry("user", &format!("…{}{newest_user}", "u".repeat(3958))),
                entry("assistant", &format!("{assistant}b")),
            ],
        ),
        (
            vec![
                ("user", unicode_user.as_str(), Some(0)),
                ("assistant", assistant.as_str(), Some(200)),
                ("user", newest_user.as_str(), Some(400)),
                ("assistant", newest_user.as_str(), Some(400)),
            ],
            None,
            vec![
                entry("user", &format!("…{}{newest_user}", "é".repeat(1937))),
                entry("assistant", &format!("…{}{newest_user}", "a".repeat(3871))),
            ],
        ),
        (
            vec![
                ("user", oversized_user.as_str(), Some(0)),
                ("assistant", "b", Some(0)),
            ],
            None,
            vec![
                entry("user", &format!("…{}", "u".repeat(8169))),
                entry("assistant", "b"),
            ],
        ),
        (
            vec![
                ("assistant", assistant.as_str(), Some(0)),
                ("user", old_user.as_str(), Some(200)),
                ("assistant", newest_user.as_str(), Some(400)),
                ("user", "b", Some(400)),
                // Trim the tied utterances before a final extends the retained suffix.
                ("user", "", Some(600)),
            ],
            Some(extended_assistant.as_str()),
            vec![
                entry("assistant", &format!("…{}{newest_user}!", "a".repeat(3957))),
                entry("user", &format!("{old_user}b")),
            ],
        ),
        (
            vec![
                ("user", old_user.as_str(), None),
                ("assistant", assistant.as_str(), None),
                ("user", newest_user.as_str(), None),
            ],
            None,
            vec![entry("assistant", &assistant)],
        ),
        (
            vec![
                ("assistant", "I will", Some(0)),
                ("user", "Stop!", Some(200)),
                ("assistant", " do it", Some(200)),
            ],
            Some("I will do it"),
            vec![entry("assistant", "I will do it"), entry("user", "Stop!")],
        ),
    ] {
        let state = RealtimeTranscriptState::default();
        let mut events = events(state.clone());
        let (sender, receiver) = async_channel::unbounded();
        events.rx_message = receiver;
        for (role, text, start_ms) in frames {
            let event_type = if role == "user" {
                "input_transcript.added"
            } else {
                "output_transcript.added"
            };
            let mut payload = json!({"type": event_type, "item": {"text": text}});
            if let Some(start_ms) = start_ms {
                payload["start_ms"] = json!(start_ms);
                payload["end_ms"] = json!(start_ms + 200);
            }
            sender
                .send(Ok(Message::Text(payload.to_string().into())))
                .await
                .unwrap();
            let delta = RealtimeTranscriptDelta { delta: text.into() };
            assert_eq!(
                events.next_event().await.unwrap(),
                Some(if role == "user" {
                    RealtimeEvent::InputTranscriptDelta(delta)
                } else {
                    RealtimeEvent::OutputTranscriptDelta(delta)
                }),
            );
        }
        if let Some(text) = final_assistant {
            sender.send(Ok(Message::Text(json!({
                "type": "turn.done",
                "turn": {"role": "assistant", "transcript": text, "start_ms": 0, "end_ms": 800}
            }).to_string().into()))).await.unwrap();
            assert_eq!(
                events.next_event().await.unwrap(),
                Some(RealtimeEvent::OutputTranscriptDone(
                    RealtimeTranscriptDone { text: text.into() }
                )),
            );
        }
        assert_eq!(state.take_transcript_tail().await, expected);
        assert_eq!(state.take_transcript_tail().await, vec![]);
    }
}