propagate response execution model identity

This commit is contained in:
GLENNA ZHANG
2026-06-12 12:26:32 -04:00
parent 4b491fd068
commit fd1096ae73
13 changed files with 520 additions and 33 deletions
@@ -15,9 +15,11 @@ use codex_app_server_protocol::RequestId;
use codex_app_server_protocol::ThreadItem;
use codex_app_server_protocol::ThreadStartParams;
use codex_app_server_protocol::ThreadStartResponse;
use codex_app_server_protocol::TurnCompletedNotification;
use codex_app_server_protocol::TurnModerationMetadataNotification;
use codex_app_server_protocol::TurnStartParams;
use codex_app_server_protocol::TurnStartResponse;
use codex_app_server_protocol::TurnStatus;
use codex_app_server_protocol::UserInput;
use core_test_support::responses;
use core_test_support::skip_if_no_network;
@@ -29,10 +31,59 @@ use wiremock::ResponseTemplate;
const DEFAULT_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
const REQUESTED_MODEL: &str = "gpt-5.4";
const SERVER_MODEL: &str = "gpt-5.3-codex";
const MODEL_SNAPSHOT: &str = "test-model-snapshot";
const TRUSTED_ACCESS_FOR_CYBER_VERIFICATION: &str = "trusted_access_for_cyber";
const CYBER_POLICY_MESSAGE: &str =
"This request has been flagged for potentially high-risk cyber activity.";
#[tokio::test]
async fn response_identity_headers_propagate_to_turn_completed_v2() -> Result<()> {
skip_if_no_network!(Ok(()));
let body = responses::sse(vec![
responses::ev_response_created("resp-1"),
responses::ev_assistant_message("msg-1", "Done"),
responses::ev_completed("resp-1"),
]);
let response = responses::sse_response(body)
.insert_header("OpenAI-Model", SERVER_MODEL)
.insert_header("OpenAI-Model-Snapshot", MODEL_SNAPSHOT);
let (thread_id, turn_id, completed, _) = run_turn_and_read_completion(response).await?;
assert_eq!(completed.thread_id, thread_id);
assert_eq!(completed.turn.id, turn_id);
assert_eq!(completed.turn.status, TurnStatus::Completed);
assert_eq!(completed.final_model.as_deref(), Some(SERVER_MODEL));
assert_eq!(completed.model_snapshot.as_deref(), Some(MODEL_SNAPSHOT));
Ok(())
}
#[tokio::test]
async fn missing_response_identity_headers_leave_turn_completed_fields_null() -> Result<()> {
skip_if_no_network!(Ok(()));
let body = responses::sse(vec![
responses::ev_response_created("resp-1"),
responses::ev_assistant_message("msg-1", "Done"),
responses::ev_completed("resp-1"),
]);
let (thread_id, turn_id, completed, params) =
run_turn_and_read_completion(responses::sse_response(body)).await?;
assert_eq!(completed.thread_id, thread_id);
assert_eq!(completed.turn.id, turn_id);
assert_eq!(completed.turn.status, TurnStatus::Completed);
assert_eq!(completed.final_model, None);
assert_eq!(completed.model_snapshot, None);
assert_eq!(params.get("finalModel"), Some(&serde_json::Value::Null));
assert_eq!(params.get("modelSnapshot"), Some(&serde_json::Value::Null));
Ok(())
}
#[tokio::test]
async fn openai_model_header_mismatch_emits_model_rerouted_notification_v2() -> Result<()> {
skip_if_no_network!(Ok(()));
@@ -433,6 +484,62 @@ async fn collect_turn_notifications_and_validate_no_warning_item(
}
}
async fn run_turn_and_read_completion(
response: ResponseTemplate,
) -> Result<(String, String, TurnCompletedNotification, serde_json::Value)> {
let server = responses::start_mock_server().await;
let _response_mock = responses::mount_response_once(&server, response).await;
let codex_home = TempDir::new()?;
create_config_toml(codex_home.path(), &server.uri())?;
let mut mcp = TestAppServer::new(codex_home.path()).await?;
timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??;
let thread_req = mcp
.send_thread_start_request(ThreadStartParams {
model: Some(REQUESTED_MODEL.to_string()),
..Default::default()
})
.await?;
let thread_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(thread_req)),
)
.await??;
let ThreadStartResponse { thread, .. } = to_response::<ThreadStartResponse>(thread_resp)?;
let turn_req = mcp
.send_turn_start_request(TurnStartParams {
thread_id: thread.id.clone(),
client_user_message_id: None,
input: vec![UserInput::Text {
text: "capture response identity".to_string(),
text_elements: Vec::new(),
}],
..Default::default()
})
.await?;
let turn_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(turn_req)),
)
.await??;
let TurnStartResponse { turn } = to_response::<TurnStartResponse>(turn_resp)?;
let notification = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_notification_message("turn/completed"),
)
.await??;
let params = notification
.params
.ok_or_else(|| anyhow::anyhow!("turn/completed notification must include params"))?;
let completed = serde_json::from_value(params.clone())?;
Ok((thread.id, turn.id, completed, params))
}
async fn collect_model_verification_notifications_and_validate_no_warning_item(
mcp: &mut TestAppServer,
) -> Result<ModelVerificationNotification> {
+8
View File
@@ -69,6 +69,12 @@ pub struct MemorySummarizeOutput {
pub memory_summary: String,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct ResponseModelIdentity {
pub final_model: Option<String>,
pub model_snapshot: Option<String>,
}
#[derive(Debug)]
pub enum ResponseEvent {
Created,
@@ -77,6 +83,8 @@ pub enum ResponseEvent {
/// Emitted when the server includes `OpenAI-Model` on the stream response.
/// This can differ from the requested model when backend safety routing applies.
ServerModel(String),
/// Authoritative execution identity reported for this response.
ServerModelIdentity(ResponseModelIdentity),
/// Emitted when the server recommends additional account verification.
ModelVerifications(Vec<ModelVerification>),
/// Emitted when the server includes moderation metadata for first-party turn presentation.
@@ -1,5 +1,6 @@
use crate::auth::SharedAuthProvider;
use crate::common::ResponseEvent;
use crate::common::ResponseModelIdentity;
use crate::common::ResponseStream;
use crate::common::ResponsesWsRequest;
use crate::error::ApiError;
@@ -633,6 +634,7 @@ async fn run_websocket_response_stream(
connection_reused: bool,
) -> Result<(), ApiError> {
let mut last_server_model: Option<String> = None;
let mut last_server_model_identity: Option<ResponseModelIdentity> = None;
send_websocket_request(
ws_stream,
request_body,
@@ -698,6 +700,18 @@ async fn run_websocket_response_stream(
.await;
last_server_model = Some(model);
}
let server_model_identity = event.response_model_identity();
if (server_model_identity.final_model.is_some()
|| server_model_identity.model_snapshot.is_some())
&& last_server_model_identity.as_ref() != Some(&server_model_identity)
{
let _ = tx_event
.send(Ok(ResponseEvent::ServerModelIdentity(
server_model_identity.clone(),
)))
.await;
last_server_model_identity = Some(server_model_identity);
}
if let Some(verifications) = model_verifications
&& tx_event
.send(Ok(ResponseEvent::ModelVerifications(verifications)))
+1
View File
@@ -33,6 +33,7 @@ pub use crate::common::Reasoning;
pub use crate::common::ReasoningContext;
pub use crate::common::ResponseCreateWsRequest;
pub use crate::common::ResponseEvent;
pub use crate::common::ResponseModelIdentity;
pub use crate::common::ResponseStream;
pub use crate::common::ResponsesApiRequest;
pub use crate::common::ResponsesWsRequest;
+185 -26
View File
@@ -1,4 +1,5 @@
use crate::common::ResponseEvent;
use crate::common::ResponseModelIdentity;
use crate::common::ResponseStream;
use crate::error::ApiError;
use crate::rate_limits::parse_all_rate_limits;
@@ -24,6 +25,7 @@ use tracing::trace;
const X_REASONING_INCLUDED_HEADER: &str = "x-reasoning-included";
const OPENAI_MODEL_HEADER: &str = "openai-model";
const OPENAI_MODEL_SNAPSHOT_HEADER: &str = "openai-model-snapshot";
const REQUEST_ID_HEADER: &str = "x-request-id";
const TRUSTED_ACCESS_FOR_CYBER_VERIFICATION: &str = "trusted_access_for_cyber";
@@ -44,6 +46,11 @@ pub fn spawn_response_stream(
.get(OPENAI_MODEL_HEADER)
.and_then(|v| v.to_str().ok())
.map(ToString::to_string);
let server_model_snapshot = stream_response
.headers
.get(OPENAI_MODEL_SNAPSHOT_HEADER)
.and_then(|v| v.to_str().ok())
.map(ToString::to_string);
let reasoning_included = stream_response
.headers
.get(X_REASONING_INCLUDED_HEADER)
@@ -63,8 +70,20 @@ pub fn spawn_response_stream(
}
let (tx_event, rx_event) = mpsc::channel::<Result<ResponseEvent, ApiError>>(1600);
tokio::spawn(async move {
if let Some(model) = server_model {
let _ = tx_event.send(Ok(ResponseEvent::ServerModel(model))).await;
if let Some(model) = server_model.as_ref() {
let _ = tx_event
.send(Ok(ResponseEvent::ServerModel(model.clone())))
.await;
}
if server_model.is_some() || server_model_snapshot.is_some() {
let _ = tx_event
.send(Ok(ResponseEvent::ServerModelIdentity(
ResponseModelIdentity {
final_model: server_model,
model_snapshot: server_model_snapshot,
},
)))
.await;
}
for snapshot in rate_limit_snapshots {
let _ = tx_event.send(Ok(ResponseEvent::RateLimits(snapshot))).await;
@@ -163,27 +182,39 @@ impl ResponsesStreamEvent {
&self.kind
}
/// Returns the effective model reported by the server, if present.
///
/// Precedence:
/// 1. `response.headers` for standard Responses stream events.
/// 2. top-level `headers` for websocket metadata events.
pub fn response_model(&self) -> Option<String> {
let response_headers_model = self
.response
fn response_headers(&self) -> Option<&Value> {
self.response
.as_ref()
.and_then(|response| response.get("headers"))
.and_then(header_openai_model_value_from_json);
.filter(|headers| headers.is_object())
.or_else(|| self.headers.as_ref().filter(|headers| headers.is_object()))
}
match response_headers_model {
Some(model) => Some(model),
None => self
.headers
.as_ref()
.and_then(header_openai_model_value_from_json),
/// Returns the execution-model identity reported by the server, if present.
///
/// Both fields are read from one container: `response.headers` takes
/// precedence over the top-level `headers` used by websocket metadata.
pub fn response_model_identity(&self) -> ResponseModelIdentity {
let headers = self.response_headers();
ResponseModelIdentity {
final_model: headers.and_then(header_openai_model_value_from_json),
model_snapshot: headers.and_then(header_openai_model_snapshot_value_from_json),
}
}
/// Preserves the legacy model-warning fallback across metadata containers.
pub(crate) fn response_model(&self) -> Option<String> {
self.response
.as_ref()
.and_then(|response| response.get("headers"))
.and_then(header_openai_model_value_from_json)
.or_else(|| {
self.headers
.as_ref()
.and_then(header_openai_model_value_from_json)
})
}
pub(crate) fn model_verifications(&self) -> Option<Vec<ModelVerification>> {
if self.kind() != "response.metadata" {
return None;
@@ -220,6 +251,17 @@ fn header_openai_model_value_from_json(value: &Value) -> Option<String> {
})
}
fn header_openai_model_snapshot_value_from_json(value: &Value) -> Option<String> {
let headers = value.as_object()?;
headers.iter().find_map(|(name, value)| {
if name.eq_ignore_ascii_case(OPENAI_MODEL_SNAPSHOT_HEADER) {
json_value_as_string(value)
} else {
None
}
})
}
fn model_verifications_from_json_value(value: &Value) -> Option<Vec<ModelVerification>> {
let verifications = value
.as_array()
@@ -418,6 +460,7 @@ pub async fn process_sse(
let mut stream = stream.eventsource();
let mut response_error: Option<ApiError> = None;
let mut last_server_model: Option<String> = None;
let mut last_server_model_identity: Option<ResponseModelIdentity> = None;
loop {
let start = Instant::now();
@@ -471,6 +514,22 @@ pub async fn process_sse(
}
last_server_model = Some(model);
}
let server_model_identity = event.response_model_identity();
if (server_model_identity.final_model.is_some()
|| server_model_identity.model_snapshot.is_some())
&& last_server_model_identity.as_ref() != Some(&server_model_identity)
{
if tx_event
.send(Ok(ResponseEvent::ServerModelIdentity(
server_model_identity.clone(),
)))
.await
.is_err()
{
return;
}
last_server_model_identity = Some(server_model_identity);
}
if let Some(verifications) = model_verifications
&& tx_event
.send(Ok(ResponseEvent::ModelVerifications(verifications)))
@@ -1068,6 +1127,10 @@ mod tests {
OPENAI_MODEL_HEADER,
HeaderValue::from_static(CYBER_RESTRICTED_MODEL_FOR_TESTS),
);
headers.insert(
OPENAI_MODEL_SNAPSHOT_HEADER,
HeaderValue::from_static(MODEL_SNAPSHOT_FOR_TESTS),
);
let bytes = stream::iter(Vec::<Result<Bytes, TransportError>>::new());
let stream_response = StreamResponse {
status: StatusCode::OK,
@@ -1094,6 +1157,20 @@ mod tests {
}
other => panic!("expected server model event, got {other:?}"),
}
let event = stream
.rx_event
.recv()
.await
.expect("expected server model identity event")
.expect("expected ok event");
assert_matches!(
event,
ResponseEvent::ServerModelIdentity(ResponseModelIdentity {
final_model: Some(final_model),
model_snapshot: Some(model_snapshot),
}) if final_model == CYBER_RESTRICTED_MODEL_FOR_TESTS
&& model_snapshot == MODEL_SNAPSHOT_FOR_TESTS
);
}
#[tokio::test]
@@ -1131,6 +1208,18 @@ mod tests {
.iter()
.any(|event| matches!(event, ResponseEvent::ModelVerifications(_)))
);
assert!(
!events
.iter()
.any(|event| matches!(event, ResponseEvent::ServerModelIdentity(_)))
);
assert!(events.iter().any(|event| matches!(
event,
ResponseEvent::Completed {
response_id,
..
} if response_id == "resp-1"
)));
}
#[tokio::test]
@@ -1173,7 +1262,8 @@ mod tests {
"response": {
"id": "resp-1",
"headers": {
"OpenAI-Model": CYBER_RESTRICTED_MODEL_FOR_TESTS
"OpenAI-Model": CYBER_RESTRICTED_MODEL_FOR_TESTS,
"OpenAI-Model-Snapshot": MODEL_SNAPSHOT_FOR_TESTS
}
}
}),
@@ -1186,14 +1276,22 @@ mod tests {
])
.await;
assert_eq!(events.len(), 3);
assert_eq!(events.len(), 4);
assert_matches!(
&events[0],
ResponseEvent::ServerModel(model) if model == CYBER_RESTRICTED_MODEL_FOR_TESTS
);
assert_matches!(&events[1], ResponseEvent::Created);
assert_matches!(
&events[2],
&events[1],
ResponseEvent::ServerModelIdentity(ResponseModelIdentity {
final_model: Some(final_model),
model_snapshot: Some(model_snapshot),
}) if final_model == CYBER_RESTRICTED_MODEL_FOR_TESTS
&& model_snapshot == MODEL_SNAPSHOT_FOR_TESTS
);
assert_matches!(&events[2], ResponseEvent::Created);
assert_matches!(
&events[3],
ResponseEvent::Completed {
response_id,
token_usage: None,
@@ -1278,13 +1376,17 @@ mod tests {
"type": "response.metadata",
"headers": {
"openai-model": CYBER_RESTRICTED_MODEL_FOR_TESTS,
"OPENAI-MODEL-SNAPSHOT": MODEL_SNAPSHOT_FOR_TESTS,
}
}))
.expect("expected event to deserialize");
assert_eq!(
ev.response_model().as_deref(),
Some(CYBER_RESTRICTED_MODEL_FOR_TESTS)
ev.response_model_identity(),
ResponseModelIdentity {
final_model: Some(CYBER_RESTRICTED_MODEL_FOR_TESTS.to_string()),
model_snapshot: Some(MODEL_SNAPSHOT_FOR_TESTS.to_string()),
}
);
}
@@ -1293,7 +1395,34 @@ mod tests {
let ev: ResponsesStreamEvent = serde_json::from_value(json!({
"type": "response.created",
"headers": {
"openai-model": "top-level-model"
"openai-model": "top-level-model",
"openai-model-snapshot": "top-level-snapshot"
},
"response": {
"id": "resp-1",
"headers": {
"openai-model": CYBER_RESTRICTED_MODEL_FOR_TESTS,
"openai-model-snapshot": MODEL_SNAPSHOT_FOR_TESTS
}
}
}))
.expect("expected event to deserialize");
assert_eq!(
ev.response_model_identity(),
ResponseModelIdentity {
final_model: Some(CYBER_RESTRICTED_MODEL_FOR_TESTS.to_string()),
model_snapshot: Some(MODEL_SNAPSHOT_FOR_TESTS.to_string()),
}
);
}
#[test]
fn responses_stream_event_does_not_mix_header_containers() {
let ev: ResponsesStreamEvent = serde_json::from_value(json!({
"type": "response.created",
"headers": {
"openai-model-snapshot": "top-level-snapshot"
},
"response": {
"id": "resp-1",
@@ -1305,8 +1434,37 @@ mod tests {
.expect("expected event to deserialize");
assert_eq!(
ev.response_model().as_deref(),
Some(CYBER_RESTRICTED_MODEL_FOR_TESTS)
ev.response_model_identity(),
ResponseModelIdentity {
final_model: Some(CYBER_RESTRICTED_MODEL_FOR_TESTS.to_string()),
model_snapshot: None,
}
);
}
#[test]
fn responses_stream_event_preserves_legacy_model_fallback() {
let ev: ResponsesStreamEvent = serde_json::from_value(json!({
"type": "response.created",
"headers": {
"openai-model": "top-level-model"
},
"response": {
"id": "resp-1",
"headers": {
"openai-model-snapshot": MODEL_SNAPSHOT_FOR_TESTS
}
}
}))
.expect("expected event to deserialize");
assert_eq!(ev.response_model().as_deref(), Some("top-level-model"));
assert_eq!(
ev.response_model_identity(),
ResponseModelIdentity {
final_model: None,
model_snapshot: Some(MODEL_SNAPSHOT_FOR_TESTS.to_string()),
}
);
}
@@ -1398,4 +1556,5 @@ mod tests {
}
const CYBER_RESTRICTED_MODEL_FOR_TESTS: &str = "gpt-5.3-codex";
const MODEL_SNAPSHOT_FOR_TESTS: &str = "test-model-snapshot";
}
+3
View File
@@ -3,6 +3,8 @@ use codex_core_skills::HostLoadedSkills;
use codex_protocol::openai_models::ToolMode;
use std::sync::atomic::AtomicBool;
use crate::session::turn_context::ModelExecutionIdentity;
/// Spawn a review thread using the given prompt.
pub(super) async fn spawn_review_thread(
sess: Arc<Session>,
@@ -152,6 +154,7 @@ pub(super) async fn spawn_review_thread(
extension_data,
turn_skills: TurnSkillsContext::new(parent_turn_context.turn_skills.outcome.clone()),
turn_timing_state: Arc::new(TurnTimingState::default()),
model_execution_identity: Arc::new(Mutex::new(ModelExecutionIdentity::default())),
server_model_warning_emitted: AtomicBool::new(false),
model_verification_emitted: AtomicBool::new(false),
};
+15
View File
@@ -40,6 +40,7 @@ use crate::responses_retry::handle_retryable_response_stream_error;
use crate::session::PreviousTurnSettings;
use crate::session::TurnInput;
use crate::session::session::Session;
use crate::session::turn_context::ModelExecutionIdentity;
use crate::session::turn_context::TurnContext;
use crate::stream_events_utils::HandleOutputCtx;
use crate::stream_events_utils::TurnItemContributorPolicy;
@@ -140,6 +141,7 @@ pub(crate) async fn run_turn(
prewarmed_client_session: Option<ModelClientSession>,
cancellation_token: CancellationToken,
) -> Option<String> {
*turn_context.model_execution_identity.lock().await = ModelExecutionIdentity::default();
let mut client_session =
prewarmed_client_session.unwrap_or_else(|| sess.services.model_client.new_session());
// TODO(ccunningham): Pre-turn compaction runs before context updates and the
@@ -242,6 +244,7 @@ pub(crate) async fn run_turn(
let SamplingRequestResult {
needs_follow_up: model_needs_follow_up,
last_agent_message: sampling_request_last_agent_message,
model_execution_identity: sampling_request_model_execution_identity,
} = sampling_request_output;
can_drain_pending_input = true;
let (has_pending_input, token_status, estimated_token_count) = async {
@@ -326,6 +329,8 @@ pub(crate) async fn run_turn(
.await;
}
}
*turn_context.model_execution_identity.lock().await =
sampling_request_model_execution_identity;
if stop_outcome.should_stop {
break;
}
@@ -1183,6 +1188,7 @@ pub(crate) async fn built_tools(
struct SamplingRequestResult {
needs_follow_up: bool,
last_agent_message: Option<String>,
model_execution_identity: ModelExecutionIdentity,
}
/// Ephemeral per-response state for streaming a single proposed plan.
@@ -1797,6 +1803,7 @@ async fn try_run_sampling_request(
FuturesOrdered::new();
let mut needs_follow_up = false;
let mut last_agent_message: Option<String> = None;
let mut model_execution_identity = ModelExecutionIdentity::default();
let mut active_item: Option<TurnItem> = None;
let mut active_tool_argument_diff_consumer: Option<(
String,
@@ -1945,6 +1952,7 @@ async fn try_run_sampling_request(
break Ok(SamplingRequestResult {
needs_follow_up: true,
last_agent_message,
model_execution_identity,
});
}
}
@@ -2033,6 +2041,12 @@ async fn try_run_sampling_request(
.store(true, Ordering::Relaxed);
}
}
ResponseEvent::ServerModelIdentity(identity) => {
model_execution_identity = ModelExecutionIdentity {
final_model: identity.final_model,
model_snapshot: identity.model_snapshot,
};
}
ResponseEvent::ModelVerifications(verifications) => {
if !turn_context
.model_verification_emitted
@@ -2081,6 +2095,7 @@ async fn try_run_sampling_request(
break Ok(SamplingRequestResult {
needs_follow_up,
last_agent_message,
model_execution_identity,
});
}
ResponseEvent::OutputTextDelta(delta) => {
@@ -43,6 +43,12 @@ pub(crate) struct TurnEnvironment {
pub(crate) shell: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub(crate) struct ModelExecutionIdentity {
pub(crate) final_model: Option<String>,
pub(crate) model_snapshot: Option<String>,
}
impl TurnEnvironment {
pub(crate) fn selection(&self) -> TurnEnvironmentSelection {
TurnEnvironmentSelection {
@@ -102,6 +108,7 @@ pub struct TurnContext {
pub(crate) extension_data: Arc<codex_extension_api::ExtensionData>,
pub(crate) turn_skills: TurnSkillsContext,
pub(crate) turn_timing_state: Arc<TurnTimingState>,
pub(crate) model_execution_identity: Arc<Mutex<ModelExecutionIdentity>>,
pub(crate) server_model_warning_emitted: AtomicBool,
pub(crate) model_verification_emitted: AtomicBool,
}
@@ -270,6 +277,7 @@ impl TurnContext {
extension_data: Arc::clone(&self.extension_data),
turn_skills: self.turn_skills.clone(),
turn_timing_state: Arc::clone(&self.turn_timing_state),
model_execution_identity: Arc::clone(&self.model_execution_identity),
server_model_warning_emitted: AtomicBool::new(
self.server_model_warning_emitted.load(Ordering::Relaxed),
),
@@ -572,6 +580,7 @@ impl Session {
extension_data,
turn_skills: TurnSkillsContext::new(skills_outcome),
turn_timing_state: Arc::new(TurnTimingState::default()),
model_execution_identity: Arc::new(Mutex::new(ModelExecutionIdentity::default())),
server_model_warning_emitted: AtomicBool::new(false),
model_verification_emitted: AtomicBool::new(false),
}
+3 -2
View File
@@ -739,11 +739,12 @@ impl Session {
});
self.emit_turn_stop_lifecycle(turn_context.extension_data.as_ref())
.await;
let model_execution_identity = turn_context.model_execution_identity.lock().await.clone();
let event = EventMsg::TurnComplete(TurnCompleteEvent {
turn_id: turn_context.sub_id.clone(),
last_agent_message,
final_model: None,
model_snapshot: None,
final_model: model_execution_identity.final_model,
model_snapshot: model_execution_identity.model_snapshot,
completed_at,
duration_ms,
time_to_first_token_ms,
+1
View File
@@ -337,6 +337,7 @@ fn response_event_records_turn_ttft(event: &ResponseEvent) -> bool {
| ResponseEvent::ReasoningContentDelta { .. } => true,
ResponseEvent::Created
| ResponseEvent::ServerModel(_)
| ResponseEvent::ServerModelIdentity(_)
| ResponseEvent::ModelVerifications(_)
| ResponseEvent::TurnModerationMetadata(_)
| ResponseEvent::ServerReasoningIncluded(_)
@@ -1103,6 +1103,73 @@ async fn responses_websocket_emits_reasoning_included_event() {
server.shutdown().await;
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn responses_websocket_uses_per_request_model_identity_metadata() {
skip_if_no_network!();
let first_identity = json!({
"type": "codex.response.metadata",
"headers": {
"OpenAI-Model": "route-first",
"OpenAI-Model-Snapshot": "snapshot-first"
}
});
let second_identity = json!({
"type": "codex.response.metadata",
"headers": {
"OpenAI-Model": "route-terminal",
"OpenAI-Model-Snapshot": "snapshot-terminal"
}
});
let server = start_websocket_server_with_headers(vec![WebSocketConnectionConfig {
requests: vec![
vec![
first_identity,
ev_response_created("resp-1"),
ev_completed("resp-1"),
],
vec![
second_identity,
ev_response_created("resp-2"),
ev_completed("resp-2"),
],
],
response_headers: vec![("OpenAI-Model".to_string(), "handshake-model".to_string())],
accept_delay: None,
close_after_requests: true,
}])
.await;
let harness = websocket_harness(&server).await;
let mut client_session = harness.client.new_session();
let prompt = prompt_with_input(vec![message_item("hello")]);
let first =
stream_until_complete_and_capture_model_identity(&mut client_session, &harness, &prompt)
.await;
let second =
stream_until_complete_and_capture_model_identity(&mut client_session, &harness, &prompt)
.await;
assert_eq!(
first,
(
Some("route-first".to_string()),
Some("snapshot-first".to_string())
)
);
assert_eq!(
second,
(
Some("route-terminal".to_string()),
Some("snapshot-terminal".to_string())
)
);
assert_eq!(server.handshakes().len(), 1);
server.shutdown().await;
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn responses_websocket_emits_rate_limit_events() {
skip_if_no_network!();
@@ -2171,6 +2238,43 @@ async fn stream_until_complete_with_service_tier(
.await;
}
async fn stream_until_complete_and_capture_model_identity(
client_session: &mut ModelClientSession,
harness: &WebsocketTestHarness,
prompt: &Prompt,
) -> (Option<String>, Option<String>) {
let mut stream = client_session
.stream(
TEST_WINDOW_ID,
prompt,
&harness.model_info,
&harness.session_telemetry,
harness.effort.clone(),
harness.summary,
/*service_tier*/ None,
/*turn_metadata_header*/ None,
&InferenceTraceContext::disabled(),
)
.await
.expect("websocket stream failed");
let mut identity = (None, None);
while let Some(event) = stream.next().await {
match event.expect("websocket response event should parse") {
ResponseEvent::ServerModelIdentity(response_identity) => {
identity = (
response_identity.final_model,
response_identity.model_snapshot,
);
}
ResponseEvent::Completed { .. } => return identity,
_ => {}
}
}
panic!("websocket stream ended before completion");
}
async fn stream_until_complete_with_turn_metadata(
client_session: &mut ModelClientSession,
harness: &WebsocketTestHarness,
@@ -29,7 +29,10 @@ use pretty_assertions::assert_eq;
use wiremock::ResponseTemplate;
const SERVER_MODEL: &str = "gpt-5.2";
const TERMINAL_SERVER_MODEL: &str = "gpt-5.1-codex";
const REQUESTED_MODEL: &str = "gpt-5.3-codex";
const FIRST_MODEL_SNAPSHOT: &str = "test-first-model-snapshot";
const TERMINAL_MODEL_SNAPSHOT: &str = "test-terminal-model-snapshot";
const TRUSTED_ACCESS_FOR_CYBER_VERIFICATION: &str = "trusted_access_for_cyber";
const CYBER_POLICY_MESSAGE: &str =
@@ -221,13 +224,15 @@ async fn openai_model_header_mismatch_only_emits_one_warning_per_turn() -> Resul
),
core_test_support::responses::ev_completed("resp-1"),
]))
.insert_header("OpenAI-Model", SERVER_MODEL);
.insert_header("OpenAI-Model", SERVER_MODEL)
.insert_header("OpenAI-Model-Snapshot", FIRST_MODEL_SNAPSHOT);
let second_response = sse_response(sse(vec![
ev_response_created("resp-2"),
ev_assistant_message("msg-1", "done"),
core_test_support::responses::ev_completed("resp-2"),
]))
.insert_header("OpenAI-Model", SERVER_MODEL);
.insert_header("OpenAI-Model", TERMINAL_SERVER_MODEL)
.insert_header("OpenAI-Model-Snapshot", TERMINAL_MODEL_SNAPSHOT);
let _mock = mount_response_sequence(&server, vec![first_response, second_response]).await;
let mut builder = test_codex().with_model(REQUESTED_MODEL);
@@ -238,18 +243,77 @@ async fn openai_model_header_mismatch_only_emits_one_warning_per_turn() -> Resul
.await?;
let mut warning_count = 0;
loop {
let turn_complete = loop {
let event = wait_for_event(&test.codex, |_| true).await;
match event {
EventMsg::Warning(warning) if warning.message.contains(REQUESTED_MODEL) => {
warning_count += 1;
}
EventMsg::TurnComplete(_) => break,
EventMsg::TurnComplete(turn_complete) => break turn_complete,
_ => {}
}
}
};
assert_eq!(warning_count, 1);
assert_eq!(
turn_complete.final_model.as_deref(),
Some(TERMINAL_SERVER_MODEL)
);
assert_eq!(
turn_complete.model_snapshot.as_deref(),
Some(TERMINAL_MODEL_SNAPSHOT)
);
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn nonterminal_response_identity_is_not_reported_when_follow_up_fails() -> Result<()> {
skip_if_no_network!(Ok(()));
let server = start_mock_server().await;
let tool_args = serde_json::json!({
"command": "echo hello",
"timeout_ms": 1_000
});
let first_response = sse_response(sse(vec![
ev_response_created("resp-1"),
ev_function_call(
"call-1",
"shell_command",
&serde_json::to_string(&tool_args)?,
),
core_test_support::responses::ev_completed("resp-1"),
]))
.insert_header("OpenAI-Model", SERVER_MODEL)
.insert_header("OpenAI-Model-Snapshot", FIRST_MODEL_SNAPSHOT);
let failed_follow_up = ResponseTemplate::new(400).set_body_json(serde_json::json!({
"error": {
"message": "synthetic follow-up failure",
"type": "invalid_request_error",
"param": null,
"code": "invalid_prompt"
}
}));
let _mock = mount_response_sequence(&server, vec![first_response, failed_follow_up]).await;
let mut builder = test_codex().with_model(REQUESTED_MODEL);
let test = builder.build(&server).await?;
test.codex
.submit(disabled_text_turn(&test, "trigger failed follow-up"))
.await?;
let turn_complete = wait_for_event(&test.codex, |event| {
matches!(event, EventMsg::TurnComplete(_))
})
.await;
let EventMsg::TurnComplete(turn_complete) = turn_complete else {
panic!("expected turn complete event");
};
assert_eq!(turn_complete.final_model, None);
assert_eq!(turn_complete.model_snapshot, None);
Ok(())
}
@@ -1207,6 +1207,7 @@ impl SessionTelemetry {
"reasoning_summary_part_added".into()
}
ResponseEvent::ServerModel(_) => "server_model".into(),
ResponseEvent::ServerModelIdentity(_) => "server_model_identity".into(),
ResponseEvent::ModelVerifications(_) => "model_verifications".into(),
ResponseEvent::TurnModerationMetadata(_) => "turn_moderation_metadata".into(),
ResponseEvent::ServerReasoningIncluded(_) => "server_reasoning_included".into(),