Preserve pending realtime speech when a call ends (#62299)

## Why

A realtime call can end with completed speech that has yet to reach a
Codex turn. The next turn needs that context even if the call's transport
has already disconnected.

## What changed

- For V3 calls with realtime frame history enabled, save pending speech
  as context for the next turn. Restore it on thread reload and exclude
  it from the turn count used by rollback.
- Drain already received transcript events and settle pending handoffs
  before saving the call's closing marker. Report recovery required if
  shutdown cannot confirm that history was saved.
- Keep transport detach separate from ending a call. Reattaching restores
  saved pending speech, and an open call can be ended from persisted
  history after a reload. Use the call ID for TUI attachments so successive
  calls on one thread have distinct history.

## Testing

Add coverage for queued speech at hangup, reconnect and stop after
reload, retries after an uncertain write, and rollback across saved
session-end context.

GitOrigin-RevId: 657491f1d7e446a1a48e22189758810c8bdd82cb
This commit is contained in:
Zahan Malkani
2026-11-18 15:24:29 +00:00
committed by copyberry
parent bd3eaf7829
commit bd00a8a42e
39 changed files with 3687 additions and 256 deletions
+15 -3
View File
@@ -1273,7 +1273,15 @@ impl ContextManager {
mut cut_idx: usize,
) -> usize {
while cut_idx > first_instruction_turn_idx {
match &snapshot[cut_idx - 1].item {
let previous = &snapshot[cut_idx - 1];
if previous
.metadata
.as_ref()
.is_some_and(|metadata| metadata.realtime_session_end_input)
{
break;
}
match &previous.item {
ResponseItem::Message {
role,
content,
@@ -1691,9 +1699,13 @@ pub(crate) fn is_user_turn_boundary(item: &ResponseItem) -> bool {
|| (role == "assistant" && is_inter_agent_instruction_content(content))
}
/// Evaluates an instruction boundary from annotated history.
/// Session-end realtime input is saved context, not an instruction that started or steered a turn.
pub(crate) fn is_instruction_turn_boundary(envelope: &ResponseItemEnvelope) -> bool {
is_user_turn_boundary(&envelope.item)
!envelope
.metadata
.as_ref()
.is_some_and(|metadata| metadata.realtime_session_end_input)
&& is_user_turn_boundary(&envelope.item)
}
fn is_inter_agent_instruction_content(content: &[ContentItem]) -> bool {
@@ -2161,6 +2161,46 @@ async fn drop_last_n_user_turns_preserves_prefix() {
assert_eq!(serde_json::to_value(retained).unwrap(), expected);
}
#[test]
fn session_end_input_does_not_consume_a_rollback_turn() {
let first = user_input_text_msg("first turn");
// Even if its content happens to look like normal pre-turn context, a saved
// hangup belongs to the preceding turn and must survive rollback of the next.
let tail =
user_input_text_msg("<environment_context>speech saved at hangup</environment_context>");
let next = user_input_text_msg("next turn");
let mut saved_tail = ResponseItemEnvelope::new(tail.clone());
saved_tail.metadata = Some(CodexHarnessMetadata {
realtime_session_end_input: true,
..Default::default()
});
for (mut items, expected) in [
(
vec![ResponseItemEnvelope::new(first.clone()), saved_tail.clone()],
Vec::new(),
),
(
vec![
ResponseItemEnvelope::new(first.clone()),
saved_tail,
ResponseItemEnvelope::new(next),
],
vec![first, tail],
),
] {
let mut live = ContextManager::default();
live.record_annotated_items(&mut items, TruncationPolicy::Tokens(10_000));
let mut checkpoint = ContextManager::default();
checkpoint.replace_annotated(live.annotated_items().to_vec());
for mut history in [live, checkpoint] {
history.drop_last_n_user_turns(/*num_turns*/ 1);
assert_eq!(raw_items(&history), expected);
}
}
}
#[test]
fn rollback_removes_assistant_sources_recorded_ahead_of_queued_input() {
let mut history = root_history();
File diff suppressed because it is too large Load Diff
@@ -1,5 +1,6 @@
//! Drives caller-owned existing calls without coupling inbound events to outbound backpressure.
//! Detach stops writes and drains accepted inbound events before flushing the transcript.
//! Caller transport closure arms the cleanup deadline even when the event queue is full.
//! Pending writes are never replayed.
//! Existing calls support v1/v3 only, so inbound handling does not issue v2 response-control writes.
@@ -14,14 +15,15 @@ use super::handle_handoff_output;
use super::handle_realtime_server_event;
use super::handle_text_input;
use super::handle_user_audio_input;
use super::realtime_transcript_delta;
use super::report_realtime_transport_loss;
use crate::context::RealtimeDelegation;
use tokio::sync::mpsc;
use tokio::task::JoinHandle;
pub(super) fn spawn_input_task(
input: RealtimeInputTask,
transcript_tail_flush: RealtimeTranscriptTailFlush,
caller_commands: mpsc::Sender<String>,
) -> JoinHandle<()> {
tokio::spawn(async move {
let RealtimeInputTask {
@@ -50,7 +52,7 @@ pub(super) fn spawn_input_task(
.take_completed_transcript(&event, RealtimeDelegation::FIELD_BYTES)
.await;
handle_realtime_server_event(
(event, realtime_transcript_delta(&completed)),
(event, completed),
&writer,
&events_tx,
&handoff_state,
@@ -91,6 +93,14 @@ pub(super) fn spawn_input_task(
let _ = read.await;
Ok(())
},
_ = caller_commands.closed() => {
// CCA drops both channel halves on terminal transport loss. Observe
// that cutoff independently of the bounded fanout queue, then drain.
stop_token.cancel();
writer.close_sideband_input();
let _ = read.await;
Ok(())
},
result = &mut read => result,
result = write => {
writer.close_sideband_input();
@@ -102,6 +112,7 @@ pub(super) fn spawn_input_task(
// Dropping the last writer aborts the transport pump without waiting for
// space in the host's outgoing queue (including for a close command).
drop(writer);
stop_token.cancel();
if let Err(err) = result
&& let RealtimeInputTaskExit::TransportLost { err, .. } =
classify_realtime_input_error(err)
@@ -107,7 +107,7 @@ pub(super) fn spawn_webrtc_sideband_input_task(
"failed to connect realtime sideband: {mapped_error}"
);
let _ = events_tx
.send((RealtimeEvent::Error(mapped_error.to_string()), None))
.send((RealtimeEvent::Error(mapped_error.to_string()), Vec::new()))
.await;
break;
}
@@ -187,6 +187,7 @@ pub(super) fn spawn_webrtc_sideband_input_task(
// Cancellation may win before the task takes its already connected observer.
close_sideband_transport(&connection).await;
}
stop_token.cancel();
let transcript_tail = transcript_state.take_transcript_tail().await;
flush_realtime_transcript_tail(&transcript_tail_flush, &transcript_tail).await;
})
@@ -2,6 +2,8 @@
use crate::session::new_submission_id;
use crate::session::session::Session;
use codex_history::RealtimeSessionInputMetadata;
use codex_history::ResponseItemEnvelope;
use codex_protocol::items::TurnItem;
use codex_protocol::items::UserMessageItem;
use codex_protocol::protocol::EventMsg;
@@ -14,11 +16,27 @@ use codex_thread_store::PersistContext;
use codex_user_input::ResolvedUserInput;
use std::sync::Arc;
pub(super) async fn record(session: &Session, text: String) -> std::io::Result<()> {
record_input(session, text, /*metadata*/ None).await
}
pub(super) async fn record_chunk(
session: &Session,
text: String,
metadata: RealtimeSessionInputMetadata,
) -> std::io::Result<()> {
record_input(session, text, Some(metadata)).await
}
#[expect(
clippy::await_holding_invalid_type,
reason = "record history before the owning task can finish or a new task can start"
)]
pub(super) async fn record(session: &Session, text: String) -> std::io::Result<()> {
async fn record_input(
session: &Session,
text: String,
metadata: Option<RealtimeSessionInputMetadata>,
) -> std::io::Result<()> {
let mut recording_context = session.new_inject_items_context().await;
Arc::get_mut(&mut recording_context)
.ok_or_else(|| std::io::Error::other("realtime transcript context is shared"))?
@@ -50,9 +68,20 @@ pub(super) async fn record(session: &Session, text: String) -> std::io::Result<(
.await;
}
let item = session.response_item_from_user_input(std::slice::from_ref(&input));
session
.record_conversation_items(&turn, turn.model_info(), &[item])
.await;
if let Some(metadata) = metadata {
let mut envelope = ResponseItemEnvelope::new(item);
envelope
.metadata
.get_or_insert_default()
.realtime_session_input = Some(Box::new(metadata));
session
.record_realtime_session_chunk(&turn, envelope)
.await?;
} else {
session
.record_conversation_items(&turn, turn.model_info(), &[item])
.await;
}
// ItemCompleted is the existing source for thread/items/list. Keep the legacy
// equivalent too; the store selects the appropriate format for this thread.
@@ -286,6 +286,7 @@ async fn natural_close_finishes_before_successor_and_ignores_old_identity() {
&old_identity,
"A".to_owned(),
RealtimeConversationEnd::TransportClosed,
/*reconnectable_session*/ false,
);
tokio::pin!(close);
assert!(futures::poll!(&mut close).is_pending());
@@ -319,6 +320,7 @@ async fn natural_close_finishes_before_successor_and_ignores_old_identity() {
&old_identity,
"A".to_owned(),
RealtimeConversationEnd::TransportClosed,
/*reconnectable_session*/ false,
)
.await;
let observed = std::iter::from_fn(|| events.try_recv().ok())
+71 -13
View File
@@ -2,7 +2,6 @@
//! transcript boundaries and deduplication state with the history reducer.
//! The reducer selects when its effects are persisted relative to their source event.
#[expect(dead_code, reason = "Activated with hangup in the next PR")]
pub(crate) mod handoff;
mod presentation;
@@ -33,6 +32,7 @@ struct ActiveSegment {
id: String,
role: RealtimeTranscriptRole,
text: String,
sealed_prefix: String,
observed_at_ms: Option<i64>,
}
@@ -56,8 +56,9 @@ impl ActiveTranscriptSegments {
if self.first_active_role == Some(role) {
self.first_active_role = self
.user
.as_ref()
.or(self.assistant.as_ref())
.iter()
.chain(self.assistant.iter())
.find(|segment| !segment.text.is_empty())
.map(|segment| segment.role);
}
segment
@@ -208,9 +209,14 @@ impl RealtimeHistoryState {
.clone()
.unwrap_or_else(|| Uuid::now_v7().to_string());
if self.active_session_id.as_deref() != Some(session_id.as_str()) {
items.append(&mut self.pending_handoff_seals);
self.seal_segments(&mut items, Continuation::Finish);
self.pending_transcript.clear();
self.preserve_transcript =
event.version == codex_protocol::protocol::RealtimeConversationVersion::V3;
self.active_session_id = Some(session_id.clone());
self.failed = false;
self.v3_utterances.clear();
items.push(RealtimeItem {
// The call ID lets a reader seek directly to its opening position.
id: if self.frames_enabled() {
@@ -245,8 +251,17 @@ impl RealtimeHistoryState {
transcript_stream =
self.finish_segment(&mut items, RealtimeTranscriptRole::Assistant, done);
}
RealtimeEvent::HandoffRequested(_) => {
if let Some(session_id) = &self.active_session_id {
RealtimeEvent::HandoffRequested(handoff) => {
// The transport takes its transcript for every request, even if admission
// fails. Rejected input remains pending for the next handoff.
self.v3_utterances.clear();
if !self.committed_handoff_ids.contains(&handoff.handoff_id)
&& !self
.handoff_inputs
.get(&handoff.handoff_id)
.is_some_and(|input| input.reserved)
&& let Some(session_id) = &self.active_session_id
{
self.pending_handoffs.push_back(session_id.clone());
}
}
@@ -312,6 +327,7 @@ impl RealtimeHistoryState {
}
EventMsg::RealtimeConversationClosed(_) => {
if let Some(session_id) = self.active_session_id.take() {
items.append(&mut self.pending_handoff_seals);
self.seal_segments(&mut items, Continuation::Finish);
items.push(RealtimeItem {
id: Uuid::now_v7().to_string(),
@@ -329,6 +345,7 @@ impl RealtimeHistoryState {
},
});
self.failed = false;
self.v3_utterances.clear();
}
}
_ => {}
@@ -383,7 +400,10 @@ impl RealtimeHistoryState {
delta: &RealtimeTranscriptDelta,
) -> Option<RealtimeTranscriptStream> {
let session_id = self.active_session_id.clone()?;
self.active_segments.first_active_role.get_or_insert(role);
if !delta.delta.is_empty() {
let _ = self.v3_utterance(role, /*start*/ true);
self.active_segments.first_active_role.get_or_insert(role);
}
let frames_enabled = self.frames_enabled();
let segment = self
.active_segments
@@ -393,6 +413,7 @@ impl RealtimeHistoryState {
id: Uuid::now_v7().to_string(),
role,
text: String::new(),
sealed_prefix: String::new(),
observed_at_ms: None,
});
let observed_at_ms = frames_enabled.then(|| {
@@ -420,7 +441,20 @@ impl RealtimeHistoryState {
role: RealtimeTranscriptRole,
done: &RealtimeTranscriptDone,
) -> Option<RealtimeTranscriptStream> {
let Some(segment) = self.active_segments.take(role) else {
let stream = self.finish_transcript_frame(items, role, done);
if let Some(utterance) = self.v3_utterance(role, /*start*/ !done.text.is_empty()) {
utterance.complete = true;
}
stream
}
fn finish_transcript_frame(
&mut self,
items: &mut Vec<RealtimeItem>,
role: RealtimeTranscriptRole,
done: &RealtimeTranscriptDone,
) -> Option<RealtimeTranscriptStream> {
let Some(mut segment) = self.active_segments.take(role) else {
if done.text.is_empty() {
return None;
}
@@ -435,10 +469,35 @@ impl RealtimeHistoryState {
}
return stream;
};
// A split leaves an empty continuation; the upstream final may repeat
// text that was already committed before the split.
// A final may extend unsealed speech, but a delayed final must not replace
// newer deltas or replay text already committed before a split.
let suffix = done
.text
.strip_prefix(&segment.sealed_prefix)
.and_then(|tail| tail.strip_prefix(&segment.text))
.filter(|suffix| !suffix.is_empty())
.map(str::to_owned);
let stream = suffix.map(|delta| {
let started_item = segment.text.is_empty().then(|| {
segment.observed_at_ms = self
.frames_enabled()
.then(|| self.observation_clock.now_ms());
RealtimeItem {
id: segment.id.clone(),
realtime_session_id: segment.session_id.clone(),
observed_at_ms: segment.observed_at_ms,
content: speech(self.frames_enabled(), role, String::new()),
}
});
segment.text.push_str(&delta);
RealtimeTranscriptStream {
started_item,
item_id: segment.id.clone(),
delta,
}
});
self.seal_active_segment(items, segment, Continuation::Finish);
None
stream
}
fn seal_segments(&mut self, items: &mut Vec<RealtimeItem>, continuation: Continuation) {
@@ -466,6 +525,7 @@ impl RealtimeHistoryState {
segment: ActiveSegment,
continuation: Continuation,
) {
let sealed_prefix = format!("{}{}", segment.sealed_prefix, segment.text);
if !segment.text.is_empty() {
let item = RealtimeItem {
id: segment.id,
@@ -482,14 +542,12 @@ impl RealtimeHistoryState {
items.push(item);
}
if matches!(continuation, Continuation::Continue) {
self.active_segments
.first_active_role
.get_or_insert(segment.role);
*self.active_segments.slot_mut(segment.role) = Some(ActiveSegment {
session_id: segment.session_id,
id: Uuid::now_v7().to_string(),
role: segment.role,
text: String::new(),
sealed_prefix,
observed_at_ms: None,
});
}
+72 -5
View File
@@ -47,6 +47,7 @@ pub(crate) struct PreparedRealtimeInput {
consumed_event_ids: Vec<String>,
pub(crate) input: String,
pub(crate) new_items: Vec<RealtimeItem>,
pub(crate) receipt: Option<RealtimeItem>,
pub(crate) reserved: bool,
reserved_turn_id: Option<String>,
pub(crate) cached_envelope: Option<ResponseItemEnvelope>,
@@ -323,6 +324,7 @@ impl RealtimeHistoryState {
consumed_event_ids,
input,
new_items: self.unassigned_handoff_seals(),
receipt: None,
reserved: false,
reserved_turn_id: None,
cached_envelope: None,
@@ -332,12 +334,77 @@ impl RealtimeHistoryState {
Some(prepared)
}
pub(crate) fn restore_handoffs(&mut self, items: &[codex_history::RolloutItem]) {
for handoff_id in items
pub(crate) fn prepare_carryover(&mut self, instruction: &str) -> Option<PreparedRealtimeInput> {
let session_id = self.active_session_id.clone()?;
let handoff_id = format!("tail:{session_id}");
if self.committed_handoff_ids.contains(&handoff_id) {
return None;
}
if let Some(prepared) = self.handoff_inputs.get(&handoff_id) {
return Some(prepared.clone());
}
let preserve_transcript = self.preserve_transcript;
let entries = self.seal_available_transcripts();
if entries.is_empty() {
return None;
}
let consumed_event_ids = entries
.iter()
.filter_map(codex_history::RolloutItem::realtime_handoff_id)
{
self.committed_handoff_ids.insert(handoff_id.to_string());
.filter_map(|(id, _, _)| id.map(str::to_string))
.collect();
let (input, sources) = RealtimeDelegation::from_events(
instruction,
&entries,
RealtimeDelegationSource::TranscriptTailFlush,
preserve_transcript,
)?;
let id = Uuid::now_v7();
let receipt = RealtimeItem {
id: id.to_string(),
realtime_session_id: session_id.clone(),
observed_at_ms: Some(self.observation_clock.now_ms()),
content: RealtimeItemContent::SessionInputSaved {
reason: codex_protocol::realtime::SessionInputReason::SessionEnd,
source_event_ids: sources.clone(),
input_item_id: codex_protocol::ResponseItemId::for_admitted_user_input(id)
.to_string(),
input: input.clone(),
},
};
let prepared = PreparedRealtimeInput {
id,
session_id,
handoff_id: handoff_id.clone(),
sources,
consumed_event_ids,
input,
new_items: self.unassigned_handoff_seals(),
receipt: Some(receipt),
reserved: false,
reserved_turn_id: None,
cached_envelope: None,
};
self.handoff_inputs.insert(handoff_id, prepared.clone());
Some(prepared)
}
pub(crate) fn restore_handoffs(&mut self, items: &[codex_history::RolloutItem]) {
for item in items {
if let Some(handoff_id) = item.realtime_handoff_id() {
self.committed_handoff_ids.insert(handoff_id.to_string());
} else if let codex_history::RolloutItem::RealtimeItem(RealtimeItem {
realtime_session_id,
content:
RealtimeItemContent::SessionInputSaved {
reason: codex_protocol::realtime::SessionInputReason::SessionEnd,
..
},
..
}) = item
{
self.committed_handoff_ids
.insert(format!("tail:{realtime_session_id}"));
}
}
}
+324 -9
View File
@@ -444,7 +444,7 @@ fn does_not_replay_a_final_transcript_after_a_promotion_split() {
let done = observe_realtime(
&mut state,
RealtimeEvent::OutputTranscriptDone(RealtimeTranscriptDone {
text: "Already spoken, with an upstream revision".to_string(),
text: "Already spoken".to_string(),
}),
);
assert!(done.items.is_empty());
@@ -738,15 +738,27 @@ fn typed_input_seals_both_roles_but_realtime_delegation_does_not(
},
]
);
for event in [
RealtimeEvent::OutputTranscriptDone(RealtimeTranscriptDone {
text: "assistant revised".to_string(),
}),
RealtimeEvent::InputTranscriptDone(RealtimeTranscriptDone {
text: "user revised".to_string(),
}),
for (role, event) in [
(
RealtimeTranscriptRole::Assistant,
RealtimeEvent::OutputTranscriptDone(RealtimeTranscriptDone {
text: "assistant revised".to_string(),
}),
),
(
RealtimeTranscriptRole::User,
RealtimeEvent::InputTranscriptDone(RealtimeTranscriptDone {
text: "user revised".to_string(),
}),
),
] {
assert!(observe_realtime(&mut state, event).items.is_empty());
assert_eq!(
contents(observe_realtime(&mut state, event)),
vec![RealtimeItemContent::TranscriptSegment {
role,
text: " revised".to_string(),
}],
);
}
}
@@ -826,3 +838,306 @@ fn recovered_v3_speech_excludes_exact_consumed_frames_and_precedes_new_chunks()
RecoveredSessionStatus::Ending
);
}
#[tokio::test]
async fn handoff_settlement_releases_rejected_sources_but_preserves_uncertain_seals() {
use codex_protocol::models::ResponseItem;
use codex_protocol::protocol::RealtimeHandoffRequested;
let mut state = started_state();
state.frame_enrollment = Some(true);
let source = observe_realtime(
&mut state,
RealtimeEvent::InputTranscriptDone(RealtimeTranscriptDone {
text: "speech".into(),
}),
)
.items
.remove(0)
.id;
let request = RealtimeHandoffRequested {
handoff_id: "handoff".into(),
item_id: "item".into(),
input_transcript: "speech".into(),
active_transcript: Vec::new(),
};
let prepared = state.prepare_handoff(&request).unwrap();
assert!(state.reserve_handoff(prepared.id));
let handoff::HandoffSettlement::Wait(settlement) = state.pending_handoff_settlement().unwrap()
else {
panic!("reserved handoff should wait for settlement");
};
state.reject_handoff(prepared.id);
settlement.notified().await;
assert!(matches!(
state.pending_handoff_settlement().unwrap(),
handoff::HandoffSettlement::Settled
));
let retry = state.prepare_handoff(&request).unwrap();
assert_eq!(retry.sources, vec![source]);
assert!(state.reserve_handoff(retry.id));
state
.cache_handoff_input(retry.id, ResponseItem::CompactionTrigger {}.into())
.unwrap();
state.reject_handoff(retry.id);
assert!(state.pending_handoff_settlement().is_err());
assert!(
state.prepare_carryover("hangup").is_none(),
"an uncertain seal must not release sources to carryover"
);
let same = state.prepare_handoff(&request).unwrap();
assert_eq!(same.id, retry.id);
assert!(state.reserve_handoff(same.id));
state.finish_handoff(same.id, /*turn_id*/ None);
assert!(matches!(
state.pending_handoff_settlement().unwrap(),
handoff::HandoffSettlement::Settled
));
}
#[test]
fn handoff_seals_stable_prefix_and_rejection_recomputes_sources() {
use codex_protocol::protocol::RealtimeHandoffRequested;
let mut state = started_state();
state.frame_enrollment = Some(true);
let stream = observe_realtime(
&mut state,
RealtimeEvent::InputTranscriptDelta(RealtimeTranscriptDelta {
delta: "partial speech".into(),
}),
)
.transcript_stream
.unwrap();
let request = RealtimeHandoffRequested {
handoff_id: "handoff".into(),
item_id: "upstream".into(),
input_transcript: "".into(),
active_transcript: Vec::new(),
};
let prepared = state.prepare_handoff(&request).unwrap();
assert_eq!(prepared.sources, vec![stream.item_id.clone()]);
assert_eq!(prepared.new_items[0].id, stream.item_id);
assert!(prepared.input.contains("user: partial speech"));
assert!(state.reserve_handoff(prepared.id));
assert!(!state.reserve_handoff(prepared.id));
// An in-flight input reserves its source; later deltas form a new event.
let continued = observe_realtime(
&mut state,
RealtimeEvent::InputTranscriptDelta(RealtimeTranscriptDelta {
delta: " more".into(),
}),
)
.transcript_stream
.unwrap();
assert_ne!(continued.item_id, stream.item_id);
let overlapping = state
.prepare_handoff(&RealtimeHandoffRequested {
handoff_id: "overlapping".into(),
..request.clone()
})
.unwrap();
assert_eq!(overlapping.sources, vec![continued.item_id]);
// A definite rejection frees the sources; a retry builds a fresh snapshot.
state.reject_handoff(prepared.id);
state.finish_handoff(overlapping.id, /*turn_id*/ None);
let retry = state.prepare_handoff(&request).unwrap();
assert_ne!(retry.id, prepared.id);
assert_eq!(retry.input, prepared.input);
assert_eq!(retry.sources, prepared.sources);
let next = state
.prepare_handoff(&RealtimeHandoffRequested {
handoff_id: "next".into(),
..request
})
.unwrap();
assert_eq!(next.sources, vec![stream.item_id]);
}
#[test]
fn handoff_fallback_is_retained_without_inventing_user_speech() {
let mut state = started_state();
state.frame_enrollment = Some(true);
let prepared = state
.prepare_handoff(&codex_protocol::protocol::RealtimeHandoffRequested {
handoff_id: "fallback".into(),
item_id: "upstream".into(),
input_transcript: "only available in the handoff".into(),
active_transcript: Vec::new(),
})
.unwrap();
assert!(prepared.sources.is_empty());
assert!(prepared.new_items.is_empty());
assert!(
prepared
.input
.contains("<input>only available in the handoff</input>")
);
assert!(
prepared
.input
.contains("<transcript_delta>user: only available in the handoff</transcript_delta>")
);
}
/// A final's added words stay on the original unsealed event and enter handoff context.
#[test]
fn final_transcript_extends_unsealed_event_without_replacing_its_identity() {
let mut state = started_state();
state.frame_enrollment = Some(true);
let start = observe_realtime(
&mut state,
RealtimeEvent::OutputTranscriptDelta(RealtimeTranscriptDelta {
delta: "A bunch of stuff".into(),
}),
)
.transcript_stream
.unwrap()
.started_item
.unwrap();
let done = observe_realtime(
&mut state,
RealtimeEvent::OutputTranscriptDone(RealtimeTranscriptDone {
text: "A bunch of stuff, including coding.".into(),
}),
);
let stream = done.transcript_stream.unwrap();
assert_eq!(stream.item_id, start.id);
assert!(stream.started_item.is_none());
assert_eq!(stream.delta, ", including coding.");
assert_eq!(done.items[0].id, start.id);
assert_eq!(done.items[0].observed_at_ms, start.observed_at_ms);
assert_eq!(
done.items[0].content,
super::speech(
/*frames_enabled*/ true,
RealtimeTranscriptRole::Assistant,
"A bunch of stuff, including coding.".into()
)
);
}
/// A final received after a handoff contributes only new words and keeps sealed evidence unchanged.
#[test]
fn final_transcript_after_handoff_seals_only_the_added_suffix() {
let mut state = started_state();
state.frame_enrollment = Some(true);
observe_realtime(
&mut state,
RealtimeEvent::OutputTranscriptDelta(RealtimeTranscriptDelta {
delta: "Already spoken".into(),
}),
);
let first = state
.prepare_handoff(&codex_protocol::protocol::RealtimeHandoffRequested {
handoff_id: "first".into(),
item_id: "first".into(),
input_transcript: "first task".into(),
active_transcript: Vec::new(),
})
.unwrap();
let done = observe_realtime(
&mut state,
RealtimeEvent::OutputTranscriptDone(RealtimeTranscriptDone {
text: "Already spoken, with more detail".into(),
}),
);
let stream = done.transcript_stream.unwrap();
let started = stream.started_item.unwrap();
assert_ne!(started.id, first.new_items[0].id);
assert_eq!(stream.delta, ", with more detail");
assert_eq!(done.items[0].id, started.id);
assert_eq!(done.items[0].observed_at_ms, started.observed_at_ms);
assert_eq!(
done.items[0].content,
super::speech(
/*frames_enabled*/ true,
RealtimeTranscriptRole::Assistant,
", with more detail".into()
)
);
assert_eq!(
first.new_items[0].content,
super::speech(
/*frames_enabled*/ true,
RealtimeTranscriptRole::Assistant,
"Already spoken".into()
)
);
}
#[test]
fn v3_completed_chunk_retires_only_its_own_frames() {
use codex_protocol::protocol::RealtimeHandoffRequested;
use codex_protocol::protocol::RealtimeTranscriptEntry;
let mut state = RealtimeHistoryState {
frame_enrollment: Some(true),
..Default::default()
};
state.observe(&EventMsg::RealtimeConversationStarted(
RealtimeConversationStartedEvent {
realtime_session_id: Some("v3-call".into()),
version: RealtimeConversationVersion::V3,
},
));
let user = |text: &str| {
RealtimeEvent::InputTranscriptDelta(RealtimeTranscriptDelta { delta: text.into() })
};
let user_done = |text: &str| {
RealtimeEvent::InputTranscriptDone(RealtimeTranscriptDone { text: text.into() })
};
let ask = |id: &str| RealtimeHandoffRequested {
handoff_id: id.into(),
item_id: id.into(),
input_transcript: "task".into(),
active_transcript: Vec::new(),
};
let chunk = |text: &str| RealtimeTranscriptEntry {
role: "user".into(),
text: text.into(),
};
// A rejected request already took this utterance from the socket but did
// not commit its frame to model history. An identical later chunk must keep it.
let old = observe_realtime(&mut state, user_done("repeat"))
.items
.remove(0)
.id;
let request = ask("rejected");
let rejected = state.prepare_handoff(&request).unwrap();
state.reject_handoff(rejected.id);
observe_realtime(&mut state, RealtimeEvent::HandoffRequested(request));
observe_realtime(&mut state, user_done("repeat"));
state.consume_recorded_chunk(&[chunk("repeat")]);
// User starts first; assistant finishes first. Handoff sources must follow
// the socket's capture order, not the order in which the frames sealed.
let user_id = observe_realtime(&mut state, user("prefix"))
.transcript_stream
.unwrap()
.item_id;
let assistant_id = observe_realtime(
&mut state,
RealtimeEvent::OutputTranscriptDone(RealtimeTranscriptDone {
text: "reply".into(),
}),
)
.items
.remove(0)
.id;
let request = ask("accepted");
let accepted = state.prepare_handoff(&request).unwrap();
assert_eq!(accepted.sources, vec![old, user_id, assistant_id]);
state.finish_handoff(accepted.id, /*turn_id*/ None);
observe_realtime(&mut state, RealtimeEvent::HandoffRequested(request));
// The transport final repeats the accepted prefix; Core seals only its
// suffix. Recording the chunk must still retire that exact suffix.
let final_text = "prefix plus more";
assert_eq!(
observe_realtime(&mut state, user_done(final_text))
.items
.len(),
1
);
state.consume_recorded_chunk(&[chunk(final_text)]);
assert!(state.prepare_carryover("ended").is_none());
}
+13 -9
View File
@@ -330,8 +330,13 @@ pub(super) async fn shutdown_session_runtime(sess: &Arc<Session>) {
if let Some(startup_prewarm) = startup_prewarm {
startup_prewarm.abort().await;
}
let _ = sess.conversation.shutdown().await;
sess.abort_all_tasks(TurnAbortReason::Interrupted).await;
let (conversation_shutdown, ()) = tokio::join!(
sess.conversation.shutdown(),
sess.abort_all_tasks(TurnAbortReason::Interrupted),
);
if let Err(err) = conversation_shutdown {
warn!("failed to shut down realtime conversation: {err}");
}
if let Some(reporting) = &sess.outcome_reporting {
reporting.handoffs.wait().await;
}
@@ -688,17 +693,16 @@ pub(super) async fn submission_loop(
let _ = reply.send(result);
false
}
Op::RealtimeConversationEnd { realtime_session_id, reply } => {
crate::realtime_conversation::handle_end(&sess, sub.id, &realtime_session_id, reply).await;
false
}
Op::RealtimeConversationDetach {
realtime_session_id,
reply,
} => {
crate::realtime_conversation::handle_detach(
&sess,
Some(&realtime_session_id),
&sub.id,
)
.await;
let _ = reply.send(Ok(()));
crate::realtime_conversation::handle_detach(&sess, &realtime_session_id, reply)
.await;
false
}
Op::RealtimeConversationAudio(params) => {
+23
View File
@@ -1,3 +1,4 @@
use super::RealtimeRecord;
use super::TurnInput as PendingTurnInput;
use super::session::Session;
use super::turn_context::TurnContext;
@@ -7,6 +8,7 @@ use codex_protocol::error::CodexErr;
use codex_protocol::error::Result as CodexResult;
use codex_protocol::models::ResponseItem;
use codex_protocol::openai_models::ModelInfo;
use codex_thread_store::PersistContext;
use std::sync::Arc;
use tokio_util::sync::CancellationToken;
@@ -26,6 +28,7 @@ impl Session {
pub(crate) async fn history_injection_context(
self: &Arc<Self>,
) -> CodexResult<Arc<TurnContext>> {
self.conversation.check_history_recovery()?;
if self.reference_context_item().await.is_some() {
let turn = self.new_inject_items_context().await;
// Compaction can clear the baseline while we build this context.
@@ -193,6 +196,26 @@ impl Session {
.await;
}
pub(crate) async fn record_realtime_session_chunk(
&self,
turn: &TurnContext,
item: ResponseItemEnvelope,
) -> std::io::Result<()> {
self.try_ensure_rollout_materialized(PersistContext::Standard)
.await?;
let (items, images) = self
.prepare_conversation_items_for_history(turn, turn.model_info(), vec![item])
.await;
self.record_prepared_items(
turn,
turn.model_info(),
items,
images,
Some(RealtimeRecord::Chunk),
)
.await
}
/// Injects items into active work, or records them without starting a turn.
pub(crate) async fn inject_no_new_turn(
&self,
+33 -13
View File
@@ -278,7 +278,6 @@ mod model_catalog_settings;
mod model_ids;
pub(crate) mod multi_agents;
mod plugin_selection;
#[expect(dead_code, reason = "Activated with hangup in the next PR")]
mod realtime_handoff;
mod realtime_history;
mod retained_context;
@@ -456,6 +455,11 @@ pub(crate) enum NetworkApprovalTurn {
AnyActive,
}
enum RealtimeRecord<'a> {
Handoff(&'a crate::realtime_history::handoff::PreparedRealtimeInput),
Chunk,
}
/// Queue and lifecycle endpoints for a running [`Session`].
///
/// Runtime state lives on `Session`; keeping these endpoints separate lets all
@@ -3041,7 +3045,7 @@ impl Session {
self.deliver_event_raw(event).await;
}
async fn deliver_event_raw(&self, event: Event) {
pub(crate) async fn deliver_event_raw(&self, event: Event) {
if let Some(parent_tx) = self.parent_observer_event_tx.get() {
let forwarded = match &event.msg {
EventMsg::RawResponseItem(item) => {
@@ -4017,12 +4021,10 @@ impl Session {
&self,
input: &[ResolvedUserInput],
) -> ResponseItem {
self.response_item_from_user_input_with_image_positions(input)
.0
Self::response_item_from_user_input_with_image_positions(input).0
}
fn response_item_from_user_input_with_image_positions(
&self,
input: &[ResolvedUserInput],
) -> (ResponseItem, HashMap<usize, usize>) {
let (message, image_positions) =
@@ -4108,7 +4110,7 @@ impl Session {
model_info: &ModelInfo,
mut items: Vec<ResponseItemEnvelope>,
image_preparations: Vec<ImagePreparationMetadata>,
realtime: Option<crate::realtime_history::handoff::PreparedRealtimeInput>,
realtime: Option<RealtimeRecord<'_>>,
) -> std::io::Result<()> {
// Save the originating history budget for replay.
// Preserve any existing tool-specific override.
@@ -4136,9 +4138,7 @@ impl Session {
let force_mcp_checkpoint = items
.iter()
.any(|envelope| crate::context_manager::is_user_turn_boundary(&envelope.item));
let cached_retry = realtime
.as_ref()
.is_some_and(|input| input.cached_envelope.is_some());
let cached_retry = matches!(&realtime, Some(RealtimeRecord::Handoff(input)) if input.cached_envelope.is_some());
let mcp_revision = (!cached_retry)
.then(|| {
self.services
@@ -4219,7 +4219,7 @@ impl Session {
});
}
}
if let Some(prepared) = &realtime {
if let Some(RealtimeRecord::Handoff(prepared)) = &realtime {
let envelope = if let Some(cached) = &prepared.cached_envelope {
cached.clone()
} else {
@@ -4245,6 +4245,24 @@ impl Session {
}
response_items = vec![envelope.item.clone()];
items = vec![envelope];
} else if matches!(&realtime, Some(RealtimeRecord::Chunk)) {
let [envelope] = items.as_slice() else {
return Err(std::io::Error::other(
"realtime chunk must contain one input",
));
};
let envelope = self
.record_realtime_chunk_input(
&mut state,
envelope.clone(),
realtime_settings_event,
policy,
)
.await?;
if realtime_initial_settings {
state.take_initial_settings_pending();
}
response_items = vec![envelope.item];
} else {
state
.pending_audio_duration_ids
@@ -4263,9 +4281,11 @@ impl Session {
metadata: image,
});
}
let persisted = if let Some(prepared) = &realtime {
let persisted = if let Some(RealtimeRecord::Handoff(prepared)) = &realtime {
self.finish_realtime_handoff(prepared, &items[0]).await;
true
} else if matches!(&realtime, Some(RealtimeRecord::Chunk)) {
true
} else {
let settings_guard =
if force_mcp_checkpoint && self.reference_context_item().await.is_none() {
@@ -6098,7 +6118,7 @@ impl Session {
// Emit full prompt telemetry only for inputs selected for recording.
turn_context.session_telemetry.user_prompt(&display_input);
let (mut response_item, user_image_content_indices) =
self.response_item_from_user_input_with_image_positions(input);
Self::response_item_from_user_input_with_image_positions(input);
if let Some(uuid) = metadata.response_item_uuid {
response_item.set_id(Some(ResponseItemId::for_admitted_user_input(uuid)));
}
@@ -6138,7 +6158,7 @@ impl Session {
model_info,
prepared_items,
image_preparations,
realtime.clone(),
realtime.as_ref().map(RealtimeRecord::Handoff),
)
.await
{
+124 -5
View File
@@ -6,9 +6,11 @@ use crate::realtime_conversation::RealtimeConversationManager;
use crate::realtime_history::handoff::HandoffSettlement;
use crate::realtime_history::handoff::PreparedRealtimeInput;
use crate::state::SessionState;
use codex_history::CodexHarnessMetadata;
use codex_history::RealtimeHandoffMetadata;
use codex_history::ResponseItemEnvelope;
use codex_history::RolloutItem;
use codex_protocol::ResponseItemId;
use codex_protocol::protocol::CodexErrorInfo;
use codex_protocol::protocol::ErrorEvent;
use codex_protocol::protocol::Event;
@@ -57,6 +59,48 @@ impl Drop for RealtimeSealGuard {
}
impl Session {
/// Persist and flush the projected chunk before publishing its sole model input.
pub(super) async fn record_realtime_chunk_input(
&self,
state: &mut SessionState,
mut envelope: ResponseItemEnvelope,
settings_event: Option<EventMsg>,
policy: TruncationPolicy,
) -> std::io::Result<ResponseItemEnvelope> {
let is_chunk = envelope
.metadata
.as_ref()
.is_some_and(|metadata| metadata.realtime_session_input.is_some());
if self.conversation.history_recovery_required() || !is_chunk {
return Err(std::io::Error::other("invalid realtime chunk input"));
}
state.history.prepare_item_sampling(&mut envelope);
let staged = state.history.stage_realtime_input(&mut envelope);
let items = settings_event
.into_iter()
.map(RolloutItem::EventMsg)
.chain(std::iter::once(RolloutItem::ResponseItem(envelope.clone())))
.collect::<Vec<_>>();
let live = self
.live_thread_for_persistence("record realtime transcript chunk")
.map_err(std::io::Error::other)?;
let mut guard = RealtimeSealGuard::new(Arc::clone(&self.conversation));
live.append_items(&items)
.await
.map_err(std::io::Error::other)?;
live.flush().await.map_err(std::io::Error::other)?;
if self.conversation.history_recovery_required() {
return Err(std::io::Error::other(
"realtime history recovery is required",
));
}
state
.history
.record_sealed_realtime_input(&envelope, staged, policy);
guard.disarm();
Ok(envelope)
}
pub(super) async fn record_realtime_handoff_input(
&self,
state: &mut SessionState,
@@ -110,6 +154,11 @@ impl Session {
seal_guard.disarm();
return Err(std::io::Error::other(error));
}
if self.conversation.history_recovery_required() {
return Err(std::io::Error::other(
"realtime history recovery is required",
));
}
// Fresh recording exposes the source only after capturing the review backup;
// a cached retry replays its already persisted provenance.
let fresh_source = if replay {
@@ -222,10 +271,7 @@ impl Session {
}
}
pub(crate) async fn route_realtime_text_input(
self: &Arc<Self>,
text: String,
) -> Result<(), &'static str> {
async fn route_realtime_text_input(self: &Arc<Self>, text: String) -> Result<(), &'static str> {
let submission_id = Uuid::now_v7().to_string();
let submission = turn_input::handle(
self,
@@ -297,7 +343,8 @@ impl Session {
.lock()
.await
.pending_handoff(id)?;
(prepared.reserved && prepared.input == *text).then_some(prepared)
(prepared.reserved && prepared.receipt.is_none() && prepared.input == *text)
.then_some(prepared)
}
pub(crate) async fn realtime_handoff_metadata(
@@ -405,6 +452,47 @@ impl Session {
}
}
#[expect(
clippy::await_holding_invalid_type,
reason = "Keep durable carryover and live model history in the same order as agent input."
)]
pub(crate) async fn record_realtime_carryover(&self, instruction: &str) -> std::io::Result<()> {
let history = self
.realtime_history
.as_ref()
.ok_or_else(|| std::io::Error::other("realtime history is disabled"))?;
let Some(prepared) = history.lock().await.prepare_carryover(instruction) else {
return Ok(());
};
let receipt = prepared
.receipt
.as_ref()
.ok_or_else(|| std::io::Error::other("missing realtime carryover receipt"))?;
let mut input = Self::realtime_carryover_input(receipt)
.ok_or_else(|| std::io::Error::other("invalid realtime carryover receipt"))?;
let mut records = prepared.new_items.clone();
records.push(receipt.clone());
let context = self.new_inject_items_context().await;
{
let mut state = self.state.lock().await;
self.live_thread_for_persistence("retain realtime context")
.map_err(std::io::Error::other)?
.seal_realtime_items(records.clone())
.await
.map_err(std::io::Error::other)?;
state.history.record_annotated_items(
std::slice::from_mut(&mut input),
context.model_info().truncation_policy.into(),
);
}
history
.lock()
.await
.finish_handoff(prepared.id, /*turn_id*/ None);
self.publish_realtime_acceptance(&records).await;
Ok(())
}
async fn publish_realtime_acceptance(&self, records: &[RealtimeItem]) {
for item in records {
let event = |payload| Event {
@@ -421,4 +509,35 @@ impl Session {
.await;
}
}
/// Hangup has no ordinary turn input. Its receipt is the only durable copy and
/// reconstructs context for the next real turn without creating a boundary.
pub(super) fn realtime_carryover_input(item: &RealtimeItem) -> Option<ResponseItemEnvelope> {
let RealtimeItemContent::SessionInputSaved {
reason: codex_protocol::realtime::SessionInputReason::SessionEnd,
input_item_id,
input,
..
} = &item.content
else {
return None;
};
let (mut response, _) =
Self::response_item_from_user_input_with_image_positions(&[ResolvedUserInput::text(
input.clone(),
)]);
response.set_id(Some(ResponseItemId::from_server(input_item_id.clone())));
if let Some(observed_at_ms) = item.observed_at_ms {
response.set_create_time_if_missing(serde_json::Number::from_f64(
observed_at_ms as f64 / 1000.0,
)?);
}
Some(ResponseItemEnvelope {
item: response,
metadata: Some(CodexHarnessMetadata {
realtime_session_end_input: true,
..Default::default()
}),
})
}
}
+38 -2
View File
@@ -7,7 +7,43 @@ use codex_protocol::protocol::RealtimeConversationRealtimeEvent;
use codex_protocol::protocol::RealtimeEvent;
use codex_protocol::realtime::RealtimeItemContent;
fn realtime_store_read_error(error: codex_thread_store::ThreadStoreError) -> std::io::Error {
match error {
error @ codex_thread_store::ThreadStoreError::Retryable { .. } => {
std::io::Error::new(std::io::ErrorKind::WouldBlock, error)
}
error => std::io::Error::other(error),
}
}
impl Session {
/// A successful close must mean the canonical close marker was sealed.
#[expect(
clippy::await_holding_invalid_type,
reason = "Keep realtime event reduction, close persistence, and delivery in the same order."
)]
pub(crate) async fn seal_realtime_close(&self, event: Event) -> anyhow::Result<()> {
let Some(history) = &self.realtime_history else {
self.send_event_raw(event).await;
return Ok(());
};
let mut history = history.lock().await;
if !history.frames_enabled() {
drop(history);
self.send_event_raw(event).await;
return Ok(());
}
self.services.mcp_runtime.observe_event(&event.msg);
let effects = history.observe(&event.msg);
self.send_realtime_history_effects(&event.id, effects)
.await?;
self.services
.rollout_thread_trace
.record_protocol_event(&event.msg);
self.deliver_event_raw(event).await;
Ok(())
}
/// Start and attach operations run sequentially in the submission loop.
/// Cache enrollment after a successful lookup so a failed start can retry.
pub(crate) async fn initialize_realtime_history(&self) -> std::io::Result<bool> {
@@ -22,7 +58,7 @@ impl Session {
.thread_store
.realtime_frames_enabled(self.thread_id())
.await
.map_err(std::io::Error::other)?;
.map_err(realtime_store_read_error)?;
let floor = if enabled
&& matches!(
self.history_initialization,
@@ -32,7 +68,7 @@ impl Session {
.thread_store
.realtime_frame_clock_floor(self.thread_id())
.await
.map_err(std::io::Error::other)?
.map_err(realtime_store_read_error)?
} else {
None
};
@@ -284,9 +284,13 @@ impl ContextManager {
| RolloutItem::EventMsg(_) => None,
})
.peekable();
let last_started_turn_id = started_turn_ids
.peek()
.map(|id| (*id).to_owned())
let last_started_turn_id = replay_items
.iter()
.rev()
.find_map(|item| match item {
RolloutItem::EventMsg(EventMsg::TurnStarted(event)) => Some(event.turn_id.clone()),
_ => None,
})
.or_else(|| resume_metadata.and_then(|metadata| metadata.last_started_turn_id.clone()));
// Saved attribution still identifies the turn when continuation eligibility was cleared.
let checkpoint_turn_id = resume_metadata.and_then(|metadata| {
@@ -534,8 +538,37 @@ impl ContextManager {
}
let rollout_suffix =
history_checkpoint.map_or(rollout_items, |checkpoint| checkpoint.suffix);
// A compacted replacement may already contain a reconstructed hangup input.
let tail_ids = rollout_suffix
.iter()
.filter_map(|item| match item {
RolloutItem::RealtimeItem(item) => match &item.content {
codex_protocol::realtime::RealtimeItemContent::SessionInputSaved {
reason: codex_protocol::realtime::SessionInputReason::SessionEnd,
input_item_id,
..
} => Some(input_item_id.as_str()),
_ => None,
},
_ => None,
})
.collect::<std::collections::HashSet<_>>();
let mut saved_tails = history
.raw_items()
.filter_map(|item| item.id())
.filter(|id| tail_ids.contains(id.as_str()))
.map(ToString::to_string)
.collect::<std::collections::HashSet<_>>();
for item in rollout_suffix {
match item {
RolloutItem::RealtimeItem(item) => {
if let Some(input) = Session::realtime_carryover_input(item)
&& let Some(id) = input.item.id()
&& saved_tails.insert(id.to_string())
{
history.replay_annotated_item(&input, truncation_policy);
}
}
RolloutItem::RetainedContext(event) => {
history.record_retained_context(event);
}
@@ -573,7 +606,6 @@ impl ContextManager {
}
RolloutItem::EventMsg(_)
| RolloutItem::TurnContext(_)
| RolloutItem::RealtimeItem(_)
| RolloutItem::WorldState(_)
| RolloutItem::SecurityRiskScore(_)
| RolloutItem::TokenUsageRecord(_)
@@ -2882,3 +2882,118 @@ async fn record_initial_history_resumed_replaced_incomplete_compacted_turn_clear
);
assert!(session.reference_context_item().await.is_none());
}
#[tokio::test]
async fn annotated_realtime_input_replays_as_the_ordinary_input() {
use codex_history::CodexHarnessMetadata;
use codex_history::RealtimeHandoffMetadata;
use codex_protocol::ResponseItemId;
use codex_protocol::realtime::RealtimeHandoffMode;
use codex_protocol::realtime::RealtimeItemContent;
let (session, turn) = make_session_and_context().await;
let mut item = user_message("accepted exactly");
item.set_id(Some(ResponseItemId::from_server("msg_acceptance".into())));
item.set_turn_id_if_missing("accepted-turn");
let envelope = ResponseItemEnvelope {
item,
metadata: Some(CodexHarnessMetadata {
realtime_handoff: Some(Box::new(RealtimeHandoffMetadata {
event_id: "event_acceptance".into(),
realtime_session_id: "voice".into(),
observed_at_ms: 42,
handoff_id: "handoff".into(),
mode: RealtimeHandoffMode::Start,
source_event_ids: vec!["speech".into()],
})),
..Default::default()
}),
};
assert!(matches!(
envelope.realtime_handoff_item().unwrap().content,
RealtimeItemContent::TurnInputAccepted { turn_id, input, .. }
if turn_id == "accepted-turn" && input == "accepted exactly"
));
let restored = session
.reconstruct_history_from_rollout(&turn, &[RolloutItem::ResponseItem(envelope.clone())])
.await;
assert_eq!(restored.history.len(), 1);
assert_eq!(restored.history[0].item, envelope.item);
assert_eq!(
restored.history[0]
.metadata
.as_ref()
.unwrap()
.realtime_handoff,
envelope.metadata.as_ref().unwrap().realtime_handoff
);
assert_eq!(restored.last_started_turn_id, None);
}
#[tokio::test]
async fn hangup_input_replays_once_and_does_not_create_a_rollback_boundary() {
use codex_protocol::realtime::RealtimeItem;
use codex_protocol::realtime::RealtimeItemContent;
let (session, turn) = make_session_and_context().await;
let receipt = RealtimeItem {
id: "event_tail".into(),
realtime_session_id: "voice".into(),
observed_at_ms: Some(42),
content: RealtimeItemContent::SessionInputSaved {
reason: codex_protocol::realtime::SessionInputReason::SessionEnd,
source_event_ids: vec!["speech".into()],
input_item_id: "msg_tail".into(),
input: "use the smaller logo".into(),
},
};
let tail = Session::realtime_carryover_input(&receipt).unwrap();
let turn_a = user_message("turn A");
let turn_b = user_message("turn B");
let rollback = RolloutItem::EventMsg(EventMsg::ThreadRolledBack(ThreadRolledBackEvent {
num_turns: 1,
}));
let records = vec![
RolloutItem::ResponseItem(turn_a.clone().into()),
RolloutItem::RealtimeItem(receipt.clone()),
RolloutItem::RealtimeItem(receipt.clone()),
];
let restored = session
.reconstruct_history_from_rollout(&turn, &records)
.await;
assert_eq!(restored.history.len(), 2);
assert_eq!(restored.history[0].item, turn_a);
assert_eq!(restored.history[1].item, tail.item);
assert!(
restored.history[1]
.metadata
.as_ref()
.unwrap()
.realtime_session_end_input
);
let mut rollback_a = records.clone();
rollback_a.push(rollback.clone());
assert!(
session
.reconstruct_history_from_rollout(&turn, &rollback_a)
.await
.history
.is_empty()
);
let mut rollback_b = records;
rollback_b.push(RolloutItem::ResponseItem(turn_b.into()));
rollback_b.push(rollback);
let restored = session
.reconstruct_history_from_rollout(&turn, &rollback_b)
.await;
assert_eq!(
restored
.history
.iter()
.map(|item| &item.item)
.collect::<Vec<_>>(),
vec![&turn_a, &tail.item]
);
}
+6 -4
View File
@@ -630,10 +630,12 @@ async fn warm_plugins_and_skills_for_session_init(
impl Session {
pub(crate) fn turn_starts_closed(&self) -> bool {
self.services
.local_agent_runtime
.suspension_root()
.is_some()
self.conversation.history_recovery_required()
|| self
.services
.local_agent_runtime
.suspension_root()
.is_some()
|| self
.outcome_reporting
.as_ref()
@@ -45,7 +45,11 @@ pub(crate) fn user_message_positions_in_rollout(items: &[RolloutItem]) -> Vec<us
for (idx, item) in items.iter().enumerate() {
match item {
RolloutItem::ResponseItem(item)
if matches!(&item.item, ResponseItem::Message { .. })
if !item
.metadata
.as_ref()
.is_some_and(|metadata| metadata.realtime_session_end_input)
&& matches!(&item.item, ResponseItem::Message { .. })
&& matches!(
event_mapping::parse_turn_item(&item.item),
Some(TurnItem::UserMessage(_))