agent/codex
2
0
Fork 0
mirror of https://github.com/pchuan98/codex.git synced 2026-07-01 00:31:56 +08:00
Code Issues Packages Projects Releases Wiki Activity

Always use AVAS for realtime WebRTC calls (#28856)

Browse Source 
## Summary

- Remove the realtime `architecture` selector from core protocol,
app-server protocol, config parsing, generated schemas, and callers.
- Always create WebRTC realtime calls with the AVAS query params:
`intent=quicksilver&architecture=avas`.
- Keep direct websocket realtime behavior on the existing config/default
path, while WebRTC starts without an explicit version now default to
realtime v1 because AVAS requires v1.

## Notes

- WebRTC realtime now means AVAS. If a caller explicitly asks to start
WebRTC with realtime v2, Codex rejects that request because the AVAS
WebRTC path only supports realtime v1. Websocket realtime is separate
and can still use realtime v2.
- The old `[realtime] architecture = "realtimeapi" | "avas"` config knob
is removed. Local configs that still set it will need to delete that
line.
- Some app-server tests that were only trying to exercise realtime v2
protocol behavior now use websocket transport, because WebRTC is
intentionally locked to AVAS/v1. Separate WebRTC tests cover the AVAS
query params, v1 startup, SDP flow, and sideband join.

## Validation

- Merged fresh `origin/main` at `83e6a786a2`.
- `just fmt`
- `just write-config-schema`
- `just write-app-server-schema`
- `git diff --check`
- `just test -p codex-api -p codex-core -p codex-app-server-protocol -p
codex-app-server realtime` (176 passed)
- `just test -p codex-protocol -p codex-config` (413 passed)
This commit is contained in:
Peter Bakkum
2026-06-18 17:11:21 -07:00
committed by GitHub
Unverified
parent 7e37354a58
commit 8e7c213f8f
21 changed files with 335 additions and 242 deletions
Download Patch File Download Diff File Expand all files Collapse all files
codex-rs/codex-api/src/endpoint/realtime_call.rs
+55 -35
View File
@@ -1,4 +1,5 @@
use crate::auth::SharedAuthProvider;
use crate::endpoint::realtime_websocket::RealtimeEventParser;
use crate::endpoint::realtime_websocket::RealtimeSessionConfig;
use crate::endpoint::realtime_websocket::session_update_session_json;
use crate::endpoint::session::EndpointSession;
@@ -9,7 +10,6 @@ use codex_client::HttpTransport;
use codex_client::Request;
use codex_client::RequestBody;
use codex_client::RequestTelemetry;
use codex_protocol::protocol::RealtimeConversationArchitecture;
use http::HeaderMap;
use http::HeaderValue;
use http::Method;
@@ -120,27 +120,12 @@ impl<T: HttpTransport> RealtimeCallClient<T> {
sdp: String,
session_config: RealtimeSessionConfig,
extra_headers: HeaderMap,
) -> Result<RealtimeCallResponse, ApiError> {
self.create_with_session_architecture_and_headers(
sdp,
session_config,
RealtimeConversationArchitecture::RealtimeApi,
extra_headers,
)
.await
}
pub async fn create_with_session_architecture_and_headers(
&self,
sdp: String,
session_config: RealtimeSessionConfig,
architecture: RealtimeConversationArchitecture,
extra_headers: HeaderMap,
) -> Result<RealtimeCallResponse, ApiError> {
trace!(target: "codex_api::realtime_websocket::wire", "realtime call request SDP: {sdp}");
// WebRTC can begin inference as soon as the peer connection comes up, so the initial
// session payload is sent with call creation. The sideband WebSocket still sends its normal
// session.update after it joins.
validate_avas_session_config(&session_config)?;
let mut session = realtime_session_json(session_config)?;
if let Some(session) = session.as_object_mut() {
session.remove("id");
@@ -159,7 +144,7 @@ impl<T: HttpTransport> RealtimeCallClient<T> {
Self::path(),
extra_headers,
Some(body),
|req| configure_realtime_call_request(req, architecture),
configure_realtime_call_request,
)
.await?;
let sdp = decode_sdp_response(resp.body.as_ref())?;
@@ -191,7 +176,7 @@ impl<T: HttpTransport> RealtimeCallClient<T> {
extra_headers,
/*body*/ None,
|req| {
configure_realtime_call_request(req, architecture);
configure_realtime_call_request(req);
req.headers.insert(
CONTENT_TYPE,
HeaderValue::from_static(MULTIPART_CONTENT_TYPE),
@@ -208,17 +193,18 @@ impl<T: HttpTransport> RealtimeCallClient<T> {
}
}
fn configure_realtime_call_request(
request: &mut Request,
architecture: RealtimeConversationArchitecture,
) {
match architecture {
RealtimeConversationArchitecture::RealtimeApi => {}
RealtimeConversationArchitecture::Avas => {
append_query_pair(&mut request.url, "intent", "quicksilver");
append_query_pair(&mut request.url, "architecture", "avas");
}
fn configure_realtime_call_request(request: &mut Request) {
append_query_pair(&mut request.url, "intent", "quicksilver");
append_query_pair(&mut request.url, "architecture", "avas");
}
fn validate_avas_session_config(session_config: &RealtimeSessionConfig) -> Result<(), ApiError> {
if session_config.event_parser != RealtimeEventParser::V1 {
return Err(ApiError::InvalidRequest {
message: "AVAS realtime calls require realtime v1".to_string(),
});
}
Ok(())
}
fn append_query_pair(url: &mut String, key: &str, value: &str) {
@@ -377,10 +363,18 @@ mod tests {
instructions: "hi".to_string(),
model: Some("gpt-realtime".to_string()),
session_id: Some(session_id.to_string()),
event_parser: RealtimeEventParser::RealtimeV2,
event_parser: RealtimeEventParser::V1,
session_mode: RealtimeSessionMode::Conversational,
output_modality: RealtimeOutputModality::Audio,
voice: RealtimeVoice::Cove,
}
}
fn realtime_v2_session_config(session_id: &str) -> RealtimeSessionConfig {
RealtimeSessionConfig {
event_parser: RealtimeEventParser::RealtimeV2,
voice: RealtimeVoice::Marin,
..realtime_session_config(session_id)
}
}
@@ -488,7 +482,10 @@ mod tests {
let request = transport.last_request.lock().unwrap().clone().unwrap();
assert_eq!(request.method, Method::POST);
assert_eq!(request.url, "https://api.openai.com/v1/realtime/calls");
assert_eq!(
request.url,
"https://api.openai.com/v1/realtime/calls?intent=quicksilver&architecture=avas"
);
assert_eq!(
request.headers.get(CONTENT_TYPE).unwrap(),
HeaderValue::from_static(MULTIPART_CONTENT_TYPE)
@@ -524,7 +521,7 @@ mod tests {
}
#[tokio::test]
async fn sends_avas_session_call_query_params() {
async fn sends_session_call_with_avas_query_params() {
let transport = CapturingTransport::new();
let client = RealtimeCallClient::new(
transport.clone(),
@@ -533,10 +530,9 @@ mod tests {
);
let response = client
.create_with_session_architecture_and_headers(
.create_with_session_and_headers(
"v=offer\r\n".to_string(),
realtime_session_config("sess-api"),
RealtimeConversationArchitecture::Avas,
HeaderMap::new(),
)
.await
@@ -558,6 +554,30 @@ mod tests {
);
}
#[tokio::test]
async fn rejects_v2_session_call_before_sending_request() {
let transport = CapturingTransport::new();
let client = RealtimeCallClient::new(
transport.clone(),
provider("https://api.openai.com/v1"),
Arc::new(DummyAuth),
);
let err = client
.create_with_session(
"v=offer\r\n".to_string(),
realtime_v2_session_config("sess-api"),
)
.await
.expect_err("v2 session config should be rejected");
assert_eq!(
err.to_string(),
"invalid request: AVAS realtime calls require realtime v1"
);
assert!(transport.last_request.lock().unwrap().is_none());
}
#[tokio::test]
async fn sends_backend_session_call_as_json_body() {
let transport = CapturingTransport::new();
@@ -587,7 +607,7 @@ mod tests {
assert_eq!(request.method, Method::POST);
assert_eq!(
request.url,
"https://chatgpt.com/backend-api/codex/realtime/calls"
"https://chatgpt.com/backend-api/codex/realtime/calls?intent=quicksilver&architecture=avas"
);
let mut expected_session = realtime_session_json(realtime_session_config("sess-backend"))
.expect("session should encode");