mirror of
https://github.com/openai/codex.git
synced 2026-11-18 22:20:48 +00:00
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:
@@ -300,6 +300,25 @@ impl LiveThread {
|
||||
.seal_realtime_items(self.thread_id, items)
|
||||
.await;
|
||||
}
|
||||
if items.last().is_some_and(|item| {
|
||||
matches!(
|
||||
item.content,
|
||||
codex_protocol::realtime::RealtimeItemContent::SessionInputSaved {
|
||||
reason: codex_protocol::realtime::SessionInputReason::SessionEnd,
|
||||
..
|
||||
}
|
||||
)
|
||||
}) {
|
||||
self.thread_store
|
||||
.seal_realtime_items(self.thread_id, items.clone())
|
||||
.await?;
|
||||
let records = items
|
||||
.into_iter()
|
||||
.map(RolloutItem::RealtimeItem)
|
||||
.collect::<Vec<_>>();
|
||||
self.observe_appended_metadata(&records).await?;
|
||||
return Ok(());
|
||||
}
|
||||
let records: Vec<_> = items.into_iter().map(RolloutItem::RealtimeItem).collect();
|
||||
self.append_items(&records).await?;
|
||||
self.flush().await
|
||||
|
||||
@@ -199,6 +199,39 @@ pub(super) async fn append_items(
|
||||
.await
|
||||
}
|
||||
|
||||
pub(super) async fn seal_realtime_items(
|
||||
store: &LocalThreadStore,
|
||||
thread_id: ThreadId,
|
||||
items: Vec<codex_protocol::realtime::RealtimeItem>,
|
||||
) -> ThreadStoreResult<()> {
|
||||
let id = items
|
||||
.last()
|
||||
.filter(|item| {
|
||||
matches!(
|
||||
item.content,
|
||||
codex_protocol::realtime::RealtimeItemContent::SessionInputSaved {
|
||||
reason: codex_protocol::realtime::SessionInputReason::SessionEnd,
|
||||
..
|
||||
}
|
||||
)
|
||||
})
|
||||
.map(|item| item.id.clone());
|
||||
let records = items.into_iter().map(RolloutItem::RealtimeItem).collect();
|
||||
if let Some(id) = id {
|
||||
seal_realtime_records(store, thread_id, id, records).await
|
||||
} else {
|
||||
append_items(
|
||||
store,
|
||||
AppendThreadItemsParams {
|
||||
thread_id,
|
||||
items: records,
|
||||
},
|
||||
)
|
||||
.await?;
|
||||
flush_thread(store, thread_id).await
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) async fn seal_realtime_input(
|
||||
store: &LocalThreadStore,
|
||||
thread_id: ThreadId,
|
||||
|
||||
@@ -547,6 +547,14 @@ impl LocalThreadStore {
|
||||
}
|
||||
|
||||
impl ThreadStore for LocalThreadStore {
|
||||
fn seal_realtime_items(
|
||||
&self,
|
||||
thread_id: ThreadId,
|
||||
items: Vec<RealtimeItem>,
|
||||
) -> ThreadStoreFuture<'_, ()> {
|
||||
Box::pin(async move { live_writer::seal_realtime_items(self, thread_id, items).await })
|
||||
}
|
||||
|
||||
fn seal_realtime_input(
|
||||
&self,
|
||||
thread_id: ThreadId,
|
||||
|
||||
@@ -3,6 +3,8 @@ use codex_protocol::models::ContentItem;
|
||||
use codex_protocol::models::ResponseItem;
|
||||
use codex_protocol::protocol::ThreadHistoryMode;
|
||||
use codex_protocol::protocol::ThreadMemoryMode;
|
||||
use codex_protocol::realtime::RealtimeItem;
|
||||
use codex_protocol::realtime::RealtimeItemContent;
|
||||
use codex_rollout::ResponseItemEnvelope;
|
||||
use codex_rollout::RolloutItem;
|
||||
use codex_rollout::RolloutRecorder;
|
||||
@@ -94,3 +96,68 @@ async fn retry_after_uncertain_local_input_seal_does_not_append_again() {
|
||||
});
|
||||
assert_eq!(accepted.count(), 1);
|
||||
}
|
||||
|
||||
/// A failed directory sync can leave the standalone hangup input in the file.
|
||||
/// A retry must confirm the original batch instead of duplicating that context.
|
||||
#[tokio::test]
|
||||
async fn retry_after_uncertain_local_carryover_seal_does_not_append_again() {
|
||||
let home = TempDir::new().unwrap();
|
||||
let uuid = Uuid::now_v7();
|
||||
let thread_id = codex_protocol::ThreadId::from_string(&uuid.to_string()).unwrap();
|
||||
let path = write_session_file_with_history_mode(
|
||||
home.path(),
|
||||
"2025-01-03T12-00-00",
|
||||
uuid,
|
||||
ThreadHistoryMode::Paginated,
|
||||
)
|
||||
.unwrap();
|
||||
let store = LocalThreadStore::new(test_config(home.path()), /*state_db*/ None);
|
||||
store
|
||||
.resume_thread(ResumeThreadParams {
|
||||
history_revision: None,
|
||||
thread_id,
|
||||
rollout_path: Some(path.clone()),
|
||||
history: None,
|
||||
include_archived: true,
|
||||
metadata: ThreadPersistenceMetadata {
|
||||
cwd: Some(home.path().to_path_buf()),
|
||||
model_provider: "test-provider".into(),
|
||||
memory_mode: ThreadMemoryMode::Enabled,
|
||||
},
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let tail = RealtimeItem {
|
||||
id: "event-tail".into(),
|
||||
realtime_session_id: "call-1".into(),
|
||||
observed_at_ms: Some(2),
|
||||
content: RealtimeItemContent::SessionInputSaved {
|
||||
reason: codex_protocol::realtime::SessionInputReason::SessionEnd,
|
||||
source_event_ids: Vec::new(),
|
||||
input_item_id: "input-tail".into(),
|
||||
input: "last words".into(),
|
||||
},
|
||||
};
|
||||
let parent = path.parent().unwrap();
|
||||
let moved = home.path().join("moved");
|
||||
std::fs::rename(parent, &moved).unwrap();
|
||||
assert!(
|
||||
store
|
||||
.seal_realtime_items(thread_id, vec![tail.clone()])
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
std::fs::rename(&moved, parent).unwrap();
|
||||
store
|
||||
.seal_realtime_items(thread_id, vec![tail.clone()])
|
||||
.await
|
||||
.unwrap();
|
||||
let (items, _, _) = RolloutRecorder::load_rollout_items(&path).await.unwrap();
|
||||
assert_eq!(
|
||||
items
|
||||
.iter()
|
||||
.filter(|item| matches!(item, RolloutItem::RealtimeItem(item) if item.id == tail.id))
|
||||
.count(),
|
||||
1
|
||||
);
|
||||
}
|
||||
|
||||
@@ -22,6 +22,13 @@ use codex_rollout::ResponseItemEnvelope;
|
||||
/// about dynamically registered contextual fragments that thread-store cannot
|
||||
/// depend on.
|
||||
pub(super) fn counts_as_boundary(envelope: &ResponseItemEnvelope) -> bool {
|
||||
if envelope
|
||||
.metadata
|
||||
.as_ref()
|
||||
.is_some_and(|metadata| metadata.realtime_session_end_input)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
let response = &envelope.item;
|
||||
if matches!(response, ResponseItem::AgentMessage { .. }) {
|
||||
return true;
|
||||
@@ -62,7 +69,13 @@ pub(super) fn drop_last_n_user_turns(history: &mut Vec<ResponseItemEnvelope>, nu
|
||||
} else {
|
||||
user_positions[user_positions.len() - count]
|
||||
};
|
||||
while cut_index > first_turn_index && is_pre_turn_context_update(&history[cut_index - 1].item) {
|
||||
while cut_index > first_turn_index
|
||||
&& !history[cut_index - 1]
|
||||
.metadata
|
||||
.as_ref()
|
||||
.is_some_and(|metadata| metadata.realtime_session_end_input)
|
||||
&& is_pre_turn_context_update(&history[cut_index - 1].item)
|
||||
{
|
||||
cut_index -= 1;
|
||||
}
|
||||
history.truncate(cut_index);
|
||||
|
||||
@@ -196,7 +196,12 @@ impl RollbackPlanner {
|
||||
content: content.clone(),
|
||||
});
|
||||
}
|
||||
} else if rollback::is_pre_turn_context_update(&response.item) {
|
||||
} else if !response
|
||||
.metadata
|
||||
.as_ref()
|
||||
.is_some_and(|metadata| metadata.realtime_session_end_input)
|
||||
&& rollback::is_pre_turn_context_update(&response.item)
|
||||
{
|
||||
// Until another user boundary arrives, this is trailing context for the
|
||||
// previous turn. Keep that fallback owner so rollback drops it when there is
|
||||
// no later turn to attach it to.
|
||||
|
||||
@@ -1740,6 +1740,76 @@ async fn migration_preserves_reverse_replay_anchor_after_pre_compaction_rollback
|
||||
assert!(replacement_history.is_empty());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn migration_does_not_count_session_end_input_in_checkpoint_rollback() {
|
||||
let first = input_response_message("user", "first turn");
|
||||
let tail = input_response_message(
|
||||
"user",
|
||||
"<environment_context>saved speech</environment_context>",
|
||||
);
|
||||
let next = input_response_message("user", "next turn");
|
||||
let mut saved_tail = codex_rollout::ResponseItemEnvelope::new(tail.clone());
|
||||
saved_tail
|
||||
.metadata
|
||||
.get_or_insert_default()
|
||||
.realtime_session_end_input = true;
|
||||
|
||||
let migrated = migrate_after_rollback(vec![
|
||||
rollout_response_item(first.clone()),
|
||||
RolloutItem::ResponseItem(saved_tail.clone()),
|
||||
rollout_response_item(next.clone()),
|
||||
])
|
||||
.await;
|
||||
assert!(migrated.iter().any(|item| {
|
||||
matches!(item, RolloutItem::ResponseItem(response) if response == &saved_tail)
|
||||
}));
|
||||
|
||||
for (before_checkpoint, after_checkpoint, expected) in [
|
||||
(
|
||||
vec![rollout_response_item(first.clone())],
|
||||
Vec::new(),
|
||||
Vec::new(),
|
||||
),
|
||||
(
|
||||
vec![rollout_response_item(first.clone())],
|
||||
vec![
|
||||
started("next-turn"),
|
||||
rollout_response_item(next.clone()),
|
||||
completed("next-turn"),
|
||||
],
|
||||
vec![first.clone(), tail],
|
||||
),
|
||||
] {
|
||||
let mut checkpoint = compacted(Vec::new());
|
||||
let RolloutItem::Compacted(item) = &mut checkpoint else {
|
||||
unreachable!();
|
||||
};
|
||||
item.replacement_history = Some(vec![first.clone().into(), saved_tail.clone()]);
|
||||
let migrated = migrate_after_rollback(
|
||||
before_checkpoint
|
||||
.into_iter()
|
||||
.chain([checkpoint])
|
||||
.chain(after_checkpoint)
|
||||
.collect(),
|
||||
)
|
||||
.await;
|
||||
let replacement = migrated
|
||||
.into_iter()
|
||||
.find_map(|item| match item {
|
||||
RolloutItem::Compacted(item) => item.replacement_history,
|
||||
_ => None,
|
||||
})
|
||||
.expect("surviving checkpoint");
|
||||
assert_eq!(
|
||||
replacement
|
||||
.into_iter()
|
||||
.map(codex_rollout::ResponseItemEnvelope::into_item)
|
||||
.collect::<Vec<_>>(),
|
||||
expected
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn migration_preserves_same_turn_evidence_across_rollback_checkpoints() {
|
||||
assert_migrated_evidence_order(/*steer_order*/ None).await;
|
||||
|
||||
Reference in New Issue
Block a user