Compare commits

...
8 Commits
Author SHA1 Message Date
ZyyandCodex 1173f6263d chore: bump version to 3.52.1
Co-authored-by: Codex <noreply@openai.com>
2026-11-18 23:02:55 +08:00
ZyyandCodex f4bed2077f fix(accounts): align Codex plan labels and wrap them in tables
Co-authored-by: Codex <noreply@openai.com>
2026-11-18 22:59:20 +08:00
Zyy 4a8b839780 fix(core): release account leases at upstream stream termination (#742) 2026-11-18 22:34:10 +08:00
ZyyandCodex f02bc80f15 fix(openai): keep frame metadata separate from forwarded headers
Co-authored-by: Codex <noreply@openai.com>
2026-11-18 21:21:37 +08:00
ZyyandCodex 32a95a9702 refactor(openai): forward turn state from the current request
Keep the client responsible for echoing turn state across requests. Scope WebSocket opening state to the first request and retain account isolation when moving a request to another account.

Co-authored-by: Codex <noreply@openai.com>
2026-11-18 20:49:26 +08:00
ZyyandCodex cc80401d5e fix(openai): preserve same-turn routing state from Codex turn metadata
Co-authored-by: Codex <noreply@openai.com>
2026-11-18 19:56:08 +08:00
ZyyandCodex 8cc6b50d85 perf(openai): defer account catalog refreshes for one hour on matching ETags
Co-authored-by: Codex <noreply@openai.com>
2026-11-18 19:19:33 +08:00
github-actions[bot] 83521e82f5 chore(release): update release channels to 3.52.0 2026-11-18 04:54:03 +00:00
44 changed files with 614 additions and 426 deletions
@@ -19,7 +19,6 @@ use crate::openai::generation::{
};
const OPENAI_SUBAGENT_KEY: &str = "x-openai-subagent";
const CODEX_TURN_METADATA_KEY: &str = "x-codex-turn-metadata";
const PASSTHROUGH_HEADERS_CONTEXT_KEY: &str = "opaque_request_headers";
const DOWNSTREAM_WEBSOCKET_CONNECTION_ID_CONTEXT_KEY: &str = "downstream_websocket_connection_id";
@@ -36,9 +35,7 @@ pub(super) enum RequestDecodeSource {
pub struct OpenAiRequestHeaders {
turn_state: Option<String>,
turn_metadata: Option<String>,
beta_features: Option<String>,
version: Option<String>,
include_timing_metrics: Option<String>,
codex_window_id: Option<String>,
parent_thread_id: Option<String>,
downstream_websocket_connection_id: Option<String>,
@@ -62,9 +59,7 @@ impl OpenAiRequestHeaders {
Self {
turn_state: header_string(headers, "x-codex-turn-state"),
turn_metadata: header_string(headers, "x-codex-turn-metadata"),
beta_features: header_string(headers, "x-codex-beta-features"),
version: header_string(headers, "version"),
include_timing_metrics: header_string(headers, "x-responsesapi-include-timing-metrics"),
codex_window_id: header_string(headers, "x-codex-window-id"),
parent_thread_id: header_string(headers, "x-codex-parent-thread-id"),
downstream_websocket_connection_id: None,
@@ -120,22 +115,18 @@ impl OpenAiRequestHeaders {
fn protocol_context(
&self,
use_websocket: Option<bool>,
frame_turn_metadata: Option<&String>,
source: RequestDecodeSource,
) -> Map<String, Value> {
let mut context = Map::new();
insert_protocol_context(&mut context, "turn_state", self.turn_state.as_ref());
insert_protocol_context(
&mut context,
"turn_metadata",
frame_turn_metadata.or(self.turn_metadata.as_ref()),
);
insert_protocol_context(&mut context, "beta_features", self.beta_features.as_ref());
insert_protocol_context(&mut context, "turn_metadata", self.turn_metadata.as_ref());
if matches!(source, RequestDecodeSource::WebSocketFrame) {
context.insert(
gateway_protocol::openai::WEBSOCKET_FRAME_CONTEXT_KEY.to_owned(),
Value::Bool(true),
);
}
insert_protocol_context(&mut context, "version", self.version.as_ref());
insert_protocol_context(
&mut context,
"include_timing_metrics",
self.include_timing_metrics.as_ref(),
);
insert_protocol_context(
&mut context,
"codex_window_id",
@@ -338,11 +329,7 @@ pub(super) fn decode_request_object(
.unwrap_or(ContinuationIntent::None);
request_headers.apply_subagent(&mut object);
let frame_turn_metadata = match source {
RequestDecodeSource::Http => None,
RequestDecodeSource::WebSocketFrame => frame_turn_metadata(&object),
};
let protocol_context = request_headers.protocol_context(use_websocket, frame_turn_metadata);
let protocol_context = request_headers.protocol_context(use_websocket, source);
let semantics =
gateway_protocol::openai::codex_responses_request_semantics(&object, &protocol_context);
@@ -381,16 +368,6 @@ pub(super) fn decode_request_object(
})
}
fn frame_turn_metadata(body: &Map<String, Value>) -> Option<&String> {
body.get("client_metadata")
.and_then(Value::as_object)
.and_then(|metadata| metadata.get(CODEX_TURN_METADATA_KEY))
.and_then(|value| match value {
Value::String(value) if !value.trim().is_empty() => Some(value),
_ => None,
})
}
fn inject_subagent_metadata(body: &mut Map<String, Value>, subagent: &str) {
let metadata = body
.entry("client_metadata".to_owned())
@@ -74,13 +74,11 @@ pub(crate) async fn responses_websocket(
&headers,
connect_info.map(|Extension(ConnectInfo(address))| address),
);
let request_headers = OpenAiRequestHeaders::from_headers(&headers);
ResponsesWebSocketAdapter::new(service).upgrade_with_client_context(
websocket,
client,
client_ip,
user_agent,
request_headers,
headers,
middleware.map(|Extension(plan)| plan),
lifetime.map(|Extension(lifetime)| lifetime),
@@ -107,7 +105,6 @@ impl ResponsesWebSocketAdapter {
client: AuthenticatedClient,
client_ip: Option<IpAddr>,
user_agent: Option<String>,
request_headers: OpenAiRequestHeaders,
raw_headers: HeaderMap,
middleware: Option<FrozenMiddlewarePlan>,
lifetime: Option<Arc<crate::middleware::CallLifetime>>,
@@ -130,7 +127,6 @@ impl ResponsesWebSocketAdapter {
connection_id,
client_ip,
user_agent,
request_headers,
raw_headers,
lifecycle: self.service.lifecycle(),
connection_guard,
@@ -150,7 +146,6 @@ struct ResponsesWebSocketSession {
connection_id: String,
client_ip: Option<IpAddr>,
user_agent: Option<String>,
request_headers: OpenAiRequestHeaders,
raw_headers: HeaderMap,
lifecycle: Arc<dyn ConnectionLifecycle>,
connection_guard: Box<dyn ConnectionGuard>,
@@ -164,8 +159,7 @@ async fn serve_responses_websocket(socket: Socket, session: ResponsesWebSocketSe
connection_id,
client_ip,
user_agent,
request_headers,
raw_headers,
mut raw_headers,
lifecycle,
connection_guard,
middleware,
@@ -178,8 +172,6 @@ async fn serve_responses_websocket(socket: Socket, session: ResponsesWebSocketSe
let cancellation = lifecycle.cancellation().child_token();
let _connection_cancellation =
crate::middleware::websocket::CancelOnDrop(Some(cancellation.clone()));
let request_headers =
request_headers.with_downstream_websocket_connection_id(connection_id.clone());
// 帧中间件可能改写终态,此时不能据原始响应关闭下游连接
let reconnect_for_replay = !middleware
.as_ref()
@@ -241,31 +233,32 @@ async fn serve_responses_websocket(socket: Socket, session: ResponsesWebSocketSe
continue;
}
request_count = request_count.saturating_add(1);
// 初步解码只保留路由事实,避免整份正文跨越准入等待和响应交付
let model_hint = match decode_response_create_with_context(&payload, &request_headers) {
Ok(decoded) => Some(decoded.metadata().requested_model().to_owned()),
Err(error) => {
trace_rejected_request(
&correlation_id,
connection.id(),
&payload,
"decode",
&error.to_string(),
);
if send_protocol_error(
&mut connection,
StatusCode::BAD_REQUEST,
error.protocol_body(),
&correlation_id,
)
.await
== ForwardOutcome::Disconnect
{
break;
// 初步解码只取帧中的模型,实际执行使用该帧当前生效的请求头
let model_hint =
match decode_response_create_with_context(&payload, &OpenAiRequestHeaders::default()) {
Ok(decoded) => Some(decoded.metadata().requested_model().to_owned()),
Err(error) => {
trace_rejected_request(
&correlation_id,
connection.id(),
&payload,
"decode",
&error.to_string(),
);
if send_protocol_error(
&mut connection,
StatusCode::BAD_REQUEST,
error.protocol_body(),
&correlation_id,
)
.await
== ForwardOutcome::Disconnect
{
break;
}
continue;
}
continue;
}
};
};
// deadline 与 Text 可能同时就绪;在任何上游执行开始前再次封住该竞争窗口
if connection.is_expired() {
trace_rejected_request(
@@ -336,6 +329,9 @@ async fn serve_responses_websocket(socket: Socket, session: ResponsesWebSocketSe
headers: encode_headers(&raw_headers),
body: Bytes::from(payload),
};
// 握手的轮次头只属于首次执行,复用连接时由各 response.create 携带本轮数据
raw_headers.remove("x-codex-turn-state");
raw_headers.remove("x-codex-turn-metadata");
let service_for_terminal = service.clone();
let replay_for_terminal = replay.clone();
let connection_id_for_terminal = connection.id().to_owned();
@@ -45,6 +45,14 @@ impl Drop for TestServer {
async fn connect(
trace: Arc<AtomicFailureTrace>,
response_headers: Vec<ProviderResponseHeader>,
) -> (TestSocket, TestServer) {
connect_with_headers(trace, response_headers, axum::http::HeaderMap::new()).await
}
async fn connect_with_headers(
trace: Arc<AtomicFailureTrace>,
response_headers: Vec<ProviderResponseHeader>,
opening_headers: axum::http::HeaderMap,
) -> (TestSocket, TestServer) {
let execution = Arc::new(AtomicFailureExecution {
client: authenticated_client("sk_ws_atomic"),
@@ -66,6 +74,7 @@ async fn connect(
request
.headers_mut()
.insert(AUTHORIZATION, "Bearer sk_ws_atomic".parse().unwrap());
request.headers_mut().extend(opening_headers);
let (socket, response) = connect_async(request).await.expect("upgrade WebSocket");
assert_eq!(response.status(), StatusCode::SWITCHING_PROTOCOLS);
(socket, server)
@@ -518,13 +527,32 @@ async fn errors_on_a_reused_connection_keep_their_own_upstream_ids() {
initial_errors: Mutex::new(VecDeque::from(errors)),
..AtomicFailureTrace::default()
});
let (mut socket, _server) = connect(trace, Vec::new()).await;
let mut opening = axum::http::HeaderMap::new();
opening.insert(
"x-codex-turn-state",
axum::http::HeaderValue::from_static("opening"),
);
opening.insert(
"x-codex-turn-metadata",
axum::http::HeaderValue::from_static(r#"{"request_kind":"turn"}"#),
);
let (mut socket, _server) = connect_with_headers(Arc::clone(&trace), Vec::new(), opening).await;
for request_id in ["req_first", "req_second"] {
send_request(&mut socket).await;
let error = next_error(&mut socket).await;
assert_eq!(error["headers"]["x-request-id"], request_id);
assert_eq!(error["headers"]["x-gateway-request-id"], "req_ws_atomic");
}
assert_eq!(
*trace.request_turn_headers.lock().unwrap(),
[
[
Some("opening".to_owned()),
Some(r#"{"request_kind":"turn"}"#.to_owned())
],
[None, None]
]
);
assert_no_duplicate_failure(&mut socket).await;
socket.close(None).await.unwrap();
}
@@ -168,21 +168,31 @@ fn response_create_should_preserve_compaction_trigger_for_openai() {
#[test]
fn response_create_should_prefer_frame_turn_metadata_over_opening_headers() {
let frame = r#"{"request_kind":"turn","tool_namespaces_info":{"workspace":{}}}"#;
let opening = r#"{"request_kind":"compaction"}"#;
let decoded = decode_response_create_with_turn_header(
json!({
"type": "response.create",
"model": "smart-code",
"input": "hello",
"client_metadata": {
"x-codex-turn-metadata": r#"{"request_kind":"turn"}"#
"x-codex-turn-metadata": frame
}
}),
r#"{"request_kind":"compaction"}"#,
opening,
);
let Operation::Generate(request) = decoded.operation() else {
panic!("Responses must map to Generate");
};
assert_eq!(
request.protocol_payload().context()["turn_metadata"],
opening
);
assert_eq!(
request.protocol_payload().body()["client_metadata"]["x-codex-turn-metadata"],
frame
);
let semantics = codex_responses_request_semantics(
request.protocol_payload().body(),
request.protocol_payload().context(),
@@ -308,6 +318,7 @@ struct AtomicFailureTrace {
committed: AtomicBool,
finalized: AtomicBool,
downstream_websocket_connection_ids: Mutex<Vec<String>>,
request_turn_headers: Mutex<Vec<[Option<String>; 2]>>,
initial_errors: Mutex<std::collections::VecDeque<EngineError>>,
first_batch: Mutex<Option<CoordinatedEvent>>,
session_drops: Arc<AtomicUsize>,
@@ -437,6 +448,11 @@ impl ExecutionService for AtomicFailureExecution {
.get("downstream_websocket_connection_id")
.and_then(Value::as_str)
{
let context = generate.protocol_payload().context();
self.trace.request_turn_headers.lock().unwrap().push(
["turn_state", "turn_metadata"]
.map(|key| context.get(key).and_then(Value::as_str).map(str::to_owned)),
);
self.trace
.downstream_websocket_connection_ids
.lock()
@@ -1947,7 +1947,7 @@ where
let store = Arc::clone(self.engine.store());
let request_id = self.request_id.clone();
let persisted = self.request_persisted;
// 错误、账号 lease 与决策 future 都跨 next_event 的取消保留
// 错误、尝试记录与决策 future 都跨 next_event 的取消保留
// 在持久化及策略回调完成前,不能再次拉流或建立新的 attempt
self.current = Some(current);
self.pending_stream_failure = Some(PendingStreamFailure {
@@ -2440,6 +2440,9 @@ where
}
async fn finish_interruption(&mut self, error: &EngineError) -> Result<(), EngineError> {
if let Some(current) = self.current.as_mut() {
current.stream.abort();
}
// 结算 I/O 可能继续等待,先冻结交付事实以保持终态与实际 HTTP 状态一致
self.response_commit.finish();
let (outcome, gateway_error) = match error {
@@ -250,8 +250,7 @@ const MAX_NATIVE_RESPONSE_EVENTS_PER_INPUT: usize = 64;
/// 这样 Coordinator 可以先持久化 attempt,再越过发送屏障
pub struct ProviderStream {
metadata: ProviderCallMetadata,
events: EventStream,
_lease: Box<dyn ResourceLease>,
source: Option<ProviderStreamSource>,
native_response_translator: Option<Box<dyn NativeResponseTranslator>>,
account_feedback: Option<ProviderStreamAccountFeedback>,
account_protection: Option<super::account_protection::AttemptProtection>,
@@ -259,7 +258,12 @@ pub struct ProviderStream {
Option<futures::future::BoxFuture<'static, Option<Result<ProviderEvent, ProviderError>>>>,
validator: Result<EventSequenceValidator, EventSequenceError>,
strict_canonical_seen: bool,
terminated: bool,
}
// 事件流内部也可能持有同一租约,结束读取时须一并丢弃
struct ProviderStreamSource {
events: EventStream,
_lease: Box<dyn ResourceLease>,
}
struct ProviderStreamAccountFeedback {
@@ -360,18 +364,25 @@ impl ProviderStream {
{
Self {
metadata,
events: Box::pin(events),
_lease: Box::new(lease),
source: Some(ProviderStreamSource {
events: Box::pin(events),
_lease: Box::new(lease),
}),
native_response_translator: None,
account_feedback: None,
account_protection: None,
protection_feedback: None,
validator: Ok(EventSequenceValidator::new()),
strict_canonical_seen: false,
terminated: false,
}
}
pub(super) fn abort(&mut self) {
self.source.take();
self.account_protection.take();
self.protection_feedback.take();
}
/// 在第一次发送前捕获反馈栅栏,诊断调用由协调器排除
#[must_use]
pub async fn with_account_error_protection(
@@ -425,6 +436,15 @@ impl ProviderStream {
/// source/target 格式不一致、单事件展开越界、终态被丢弃或 Provider 转换失败时
/// 返回错误
pub fn translate_native_response(
&mut self,
event: ProviderEvent,
terminal: bool,
) -> Result<Vec<ProviderEvent>, ProviderError> {
self.translate_event(event, terminal)
.inspect_err(|_| self.abort())
}
fn translate_event(
&mut self,
mut event: ProviderEvent,
terminal: bool,
@@ -979,8 +999,12 @@ impl Stream for ProviderStream {
};
}
let result = this.poll_event(context);
let upstream_finished = matches!(&result, Poll::Ready(Some(Err(_)) | None));
if upstream_finished {
this.source.take();
}
// 客户端可在成功终态后停止拉取,不能依赖之后的 EOF 才清除保护证据
let protection_terminal = matches!(&result, Poll::Ready(Some(Err(_)) | None))
let protection_terminal = upstream_finished
|| (matches!(&result, Poll::Ready(Some(Ok(_))))
&& this
.account_protection
@@ -1003,14 +1027,14 @@ impl ProviderStream {
context: &mut Context<'_>,
) -> Poll<Option<Result<ProviderEvent, ProviderError>>> {
let this = self;
if this.terminated {
let Some(source) = this.source.as_mut() else {
return Poll::Ready(None);
}
};
if let Some(feedback) = this.account_feedback.as_mut() {
feedback.start();
}
match this.events.as_mut().poll_next(context) {
match source.events.as_mut().poll_next(context) {
Poll::Pending => Poll::Pending,
Poll::Ready(Some(Ok(event))) => {
// 纯 wire 流的 facts 仍只是旁路观测;一旦交付 canonical-only
@@ -1025,7 +1049,6 @@ impl ProviderStream {
}
}
if this.strict_canonical_seen && this.validator.is_err() {
this.terminated = true;
let error =
ProviderError::new(ProviderErrorKind::Protocol, UpstreamSendState::Sent);
if let Some(feedback) = this.account_feedback.as_mut() {
@@ -1042,14 +1065,12 @@ impl ProviderStream {
Poll::Ready(Some(Ok(event)))
}
Poll::Ready(Some(Err(error))) => {
this.terminated = true;
if let Some(feedback) = this.account_feedback.as_mut() {
feedback.report_failure(&error);
}
Poll::Ready(Some(Err(error)))
}
Poll::Ready(None) => {
this.terminated = true;
let validation = if this.strict_canonical_seen {
this.validator
.as_ref()
@@ -299,14 +299,17 @@ fn complete_success_is_reported_once_but_unfinished_drop_is_not_success() {
Ok(gateway_core::event::GatewayEvent::Started(response.clone()).into()),
Ok(gateway_core::event::GatewayEvent::Completed(response).into()),
]);
let mut completed = ProviderStream::new(metadata(), events, ())
let released = Arc::new(AtomicUsize::new(0));
let mut completed = ProviderStream::new(metadata(), events, Lease(released.clone()))
.with_account_error_protection(store.clone(), Arc::new(policy().compile()), 5)
.await;
assert!(completed.next().await.unwrap().is_ok());
assert_eq!(store.successes.load(Ordering::SeqCst), 0);
assert!(completed.next().await.unwrap().is_ok());
assert_eq!(store.successes.load(Ordering::SeqCst), 1);
assert_eq!(released.load(Ordering::SeqCst), 0);
assert!(completed.next().await.is_none());
assert_eq!(released.load(Ordering::SeqCst), 1);
assert!(completed.next().await.is_none());
assert_eq!(store.successes.load(Ordering::SeqCst), 1);
});
@@ -351,27 +354,27 @@ fn stalled_begin_and_feedback_are_bounded_and_preserve_original_failure() {
}
#[test]
fn cancelling_pending_feedback_releases_lease_and_does_not_report_success() {
fn failed_stream_releases_lease_while_protection_feedback_is_pending() {
futures::executor::block_on(async {
let store = Arc::new(Feedback {
stalled_feedback: true,
..Feedback::default()
});
let released = Arc::new(AtomicUsize::new(0));
let mut stream = ProviderStream::new(
metadata(),
stream::iter([Err(failure("invalid_prompt"))]),
Lease(released.clone()),
)
.with_account_error_protection(store.clone(), Arc::new(policy().compile()), 5)
.await;
let lease = Arc::new(Lease(released.clone()));
let events = stream::unfold(Arc::clone(&lease), |lease| async move {
Some((Err(failure("invalid_prompt")), lease))
});
let mut stream = ProviderStream::new(metadata(), events, lease)
.with_account_error_protection(store.clone(), Arc::new(policy().compile()), 5)
.await;
assert!(
timeout(Duration::from_millis(10), stream.next())
.await
.is_err()
);
drop(stream);
assert_eq!(released.load(Ordering::SeqCst), 1);
drop(stream);
assert_eq!(store.successes.load(Ordering::SeqCst), 0);
});
}
@@ -898,7 +898,7 @@ impl Provider for ScriptedProvider {
futures::stream::iter(items.into_iter().map(canonical_provider_event))
.chain(futures::stream::pending()),
),
(),
TrackedLease(Arc::clone(&self.released_leases)),
))
}
Script::ObservedStream { account_id, items } => {
@@ -3402,7 +3402,16 @@ fn recovered_credential_retries_the_same_account_exactly_once() {
CancellationToken::new(),
))
.expect("start execution");
block_on(session.collect_uncommitted()).expect("recovered account succeeds");
let (release, gate) = oneshot::channel();
*store.intermediate_gate.lock().unwrap() = Some(gate);
block_on(async {
let mut collect = Box::pin(session.collect_uncommitted());
assert!(futures::poll!(collect.as_mut()).is_pending());
assert_eq!(provider.contexts.lock().unwrap().len(), 1);
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 1);
release.send(()).unwrap();
collect.await.expect("recovered account succeeds");
});
block_on(session.commit_downstream(Some(200))).expect("commit response");
let contexts = provider.contexts.lock().expect("contexts lock");
@@ -5408,7 +5417,7 @@ fn delivered_prelude_allows_retry_without_control_until_non_replayable_delivery(
fn cancellation_before_pending_delivery_commit_reaches_terminal_state() {
let operation = generate_operation();
let route_plan = plan(&operation);
let (coordinator, store, _) = coordinator(vec![Script::Stream {
let (coordinator, store, provider) = coordinator(vec![Script::Stream {
account_id: "acct_first",
items: complete_stream(None),
}]);
@@ -5429,7 +5438,15 @@ fn cancellation_before_pending_delivery_commit_reaches_terminal_state() {
CommitRequirement::CommitBeforeDelivery
);
block_on(session.cancel_and_finalize()).expect("cancel finalization");
let (release, gate) = oneshot::channel();
*store.send_gate.lock().unwrap() = Some(gate);
block_on(async {
let mut cancel = Box::pin(session.cancel_and_finalize());
assert!(futures::poll!(cancel.as_mut()).is_pending());
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 1);
release.send(()).unwrap();
cancel.await.expect("cancel finalization");
});
assert!(session.is_finalized());
let state = store.state.lock().expect("store lock");
@@ -5946,7 +5963,7 @@ fn interrupted_stream_failure_preserves_the_original_attempt_and_retry_decision(
let mut resumed = Box::pin(session.next_event());
assert!(futures::poll!(resumed.as_mut()).is_pending());
assert_eq!(provider.contexts.lock().unwrap().len(), 1);
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 0);
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 1);
release
.send(())
.expect("the original write still owns its receiver");
@@ -6144,6 +6161,7 @@ fn charged_terminal_write_resumes_without_replacing_success_failure_or_send_fact
assert!(futures::poll!(collect.as_mut()).is_pending());
} else {
session.collect_uncommitted().await.unwrap();
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 1);
let mut commit = Box::pin(session.commit_downstream(Some(200)));
assert!(futures::poll!(commit.as_mut()).is_pending());
}
@@ -6187,7 +6205,7 @@ fn charged_terminal_write_resumes_without_replacing_success_failure_or_send_fact
fn deadline_after_commit_is_persisted_as_incomplete() {
let operation = generate_operation();
let route_plan = plan(&operation);
let (coordinator, store, _) = coordinator(vec![Script::HangingStream {
let (coordinator, store, provider) = coordinator(vec![Script::HangingStream {
account_id: "acct_first",
items: vec![Ok(GatewayEvent::Started(ResponseMeta::new(
"response-1",
@@ -6215,6 +6233,7 @@ fn deadline_after_commit_is_persisted_as_incomplete() {
let error = block_on(session.next_event()).expect_err("deadline elapses mid-stream");
assert!(matches!(error, EngineError::Deadline));
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 1);
let state = store.state.lock().expect("store lock");
assert_eq!(state.finalizations[0].outcome, ExecutionOutcome::Incomplete);
assert!(state.finalizations[0].committed);
@@ -6491,8 +6510,6 @@ fn connection_recovery_rotates_only_after_retrying_the_first_account() {
assert_eq!(context.transport(), AttemptTransport::Fallback);
}
assert_eq!(store.state.lock().unwrap().intermediate_failures, 2);
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 2);
drop(session);
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 3);
}
@@ -6556,8 +6573,6 @@ fn connection_recovery_keeps_one_account_and_http_transport_until_success() {
let state = store.state.lock().unwrap();
assert_eq!(state.intermediate_failures, 3);
assert_eq!(state.finalizations[0].outcome, ExecutionOutcome::Succeeded);
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 3);
drop(session);
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 4);
},
)));
@@ -6654,8 +6669,6 @@ fn connection_recovery_does_not_delay_existing_account_rotation() {
let state = store.state.lock().unwrap();
assert_eq!(state.intermediate_failures, 2);
assert_eq!(state.finalizations[0].outcome, ExecutionOutcome::Succeeded);
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 2);
drop(session);
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 3);
}
@@ -6749,8 +6762,6 @@ fn connection_recovery_exhaustion_preserves_transport_failure() {
store.state.lock().unwrap().finalizations[0].attempt_count,
4
);
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 3);
drop(session);
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 4);
}
@@ -1955,6 +1955,7 @@ impl NativeResponseTranslator for FailingNativeResponseTranslator {
struct FailingNativeResponseProvider {
calls: Arc<AtomicUsize>,
lease: Arc<()>,
}
#[async_trait]
@@ -2010,7 +2011,7 @@ impl Provider for FailingNativeResponseProvider {
GatewayEvent::Completed(response),
)),
]),
(),
Arc::clone(&self.lease),
)
.with_native_response_translator(FailingNativeResponseTranslator::default()))
}
@@ -2020,8 +2021,10 @@ impl Provider for FailingNativeResponseProvider {
fn native_response_failure_after_downstream_commit_is_not_replayed() {
block_on(async {
let calls = Arc::new(AtomicUsize::new(0));
let lease = Arc::new(());
let provider_index = ProviderRegistry::new([Arc::new(FailingNativeResponseProvider {
calls: Arc::clone(&calls),
lease: Arc::clone(&lease),
}) as Arc<dyn Provider>])
.unwrap();
let generation = super::extensions::reference("native-response-failure");
@@ -2054,6 +2057,7 @@ fn native_response_failure_after_downstream_commit_is_not_replayed() {
}));
started.session.commit_downstream(Some(200)).await.unwrap();
let active_refs = Arc::strong_count(&lease);
let error = started.session.next_event().await.unwrap_err();
assert!(matches!(
error,
@@ -2061,6 +2065,7 @@ fn native_response_failure_after_downstream_commit_is_not_replayed() {
if error.kind() == ProviderErrorKind::Protocol
&& error.send_state() == UpstreamSendState::Sent
));
assert_eq!(Arc::strong_count(&lease), active_refs - 1);
assert_eq!(calls.load(Ordering::SeqCst), 1);
started.session.detach_finalize().await;
});
@@ -6,6 +6,38 @@ const MULTI_AGENT_MODE_OPEN_TAG: &str = "<multi_agent_mode>";
const MULTI_AGENT_MODE_CLOSE_TAG: &str = "</multi_agent_mode>";
const PROACTIVE_MULTI_AGENT_MODE_PREFIX: &str = "Proactive multi-agent delegation is active.";
/// 标记实际入站的 Responses WS 帧,独立于出站传输偏好
pub const WEBSOCKET_FRAME_CONTEXT_KEY: &str = "websocket_frame";
/// 当前帧携带的完整元数据仅用于解释正文,握手或 HTTP 头保留各自的出站值
#[must_use]
pub fn observed_turn_metadata<'a>(
body: &'a Map<String, Value>,
header: Option<&'a str>,
websocket_frame: bool,
) -> Option<&'a str> {
if websocket_frame && let Some(frame) = client_metadata_string(body, "x-codex-turn-metadata") {
return Some(frame);
}
header
}
/// HTTP 请求使用本次请求头,WS 帧使用本次正文或首次握手头
#[must_use]
pub fn context_turn_metadata<'a>(
body: &'a Map<String, Value>,
context: &'a Map<String, Value>,
) -> Option<&'a str> {
observed_turn_metadata(
body,
context.get("turn_metadata").and_then(Value::as_str),
context
.get(WEBSOCKET_FRAME_CONTEXT_KEY)
.and_then(Value::as_bool)
== Some(true),
)
}
/// 各 Codex 端点共用的显式根会话身份
/// 连接边界的 session_id 优先,
/// 正文及官方 metadata 只做回退;不从 turn、window 或请求内容猜测归属
@@ -24,9 +56,7 @@ pub fn codex_account_session_id(
client_metadata_string(body, "session_id")
.map(str::to_owned)
.or_else(|| request_turn_metadata(body).and_then(turn_metadata_session_id))
.or_else(|| {
non_empty_string(context.get("turn_metadata")).and_then(turn_metadata_session_id)
})
.or_else(|| context_turn_metadata(body, context).and_then(turn_metadata_session_id))
.or_else(|| non_empty_string(body.get("session_id")).map(str::to_owned))
.or_else(|| codex_session_id(body, context))
}
@@ -40,9 +70,7 @@ pub fn codex_account_thread_id(
client_metadata_string(body, "thread_id")
.map(str::to_owned)
.or_else(|| request_turn_metadata(body).and_then(turn_metadata_thread_id))
.or_else(|| {
non_empty_string(context.get("turn_metadata")).and_then(turn_metadata_thread_id)
})
.or_else(|| context_turn_metadata(body, context).and_then(turn_metadata_thread_id))
.or_else(|| codex_thread_id(body, context))
}
@@ -64,7 +92,7 @@ pub fn codex_turn_id(body: &Map<String, Value>, context: &Map<String, Value>) ->
client_metadata_string(body, "turn_id")
.map(str::to_owned)
.or_else(|| request_turn_metadata(body).and_then(turn_metadata_turn_id))
.or_else(|| non_empty_string(context.get("turn_metadata")).and_then(turn_metadata_turn_id))
.or_else(|| context_turn_metadata(body, context).and_then(turn_metadata_turn_id))
.or_else(|| codex_identity_field(body, context, "turn_id"))
}
@@ -90,7 +118,8 @@ fn codex_identity_field(
.or_else(|| client_metadata_string(body, field))
.map(str::to_owned)
.or_else(|| {
let metadata = non_empty_string(context.get("turn_metadata"))
let metadata = context_turn_metadata(body, context)
.filter(|value| !value.trim().is_empty())
.or_else(|| request_turn_metadata(body))?;
let metadata: Value = serde_json::from_str(metadata).ok()?;
non_empty_string(metadata.get(field)).map(str::to_owned)
@@ -127,7 +156,7 @@ pub fn codex_responses_request_semantics(
) -> CodexResponsesRequestSemantics {
codex_responses_request_semantics_with_turn_metadata(
body,
context.get("turn_metadata").and_then(Value::as_str),
context_turn_metadata(body, context),
None,
)
}
@@ -21,9 +21,10 @@ mod headers;
pub mod sse;
pub use codex::{
CodexResponsesRequestSemantics, codex_account_session_id, codex_account_thread_id,
codex_responses_request_semantics, codex_responses_request_semantics_with_turn_metadata,
codex_session_id, codex_thread_id, codex_turn_id, turn_metadata_session_id,
CodexResponsesRequestSemantics, WEBSOCKET_FRAME_CONTEXT_KEY, codex_account_session_id,
codex_account_thread_id, codex_responses_request_semantics,
codex_responses_request_semantics_with_turn_metadata, codex_session_id, codex_thread_id,
codex_turn_id, context_turn_metadata, observed_turn_metadata, turn_metadata_session_id,
turn_metadata_thread_id, turn_metadata_turn_id,
};
pub use headers::{
@@ -32,7 +32,7 @@ pub fn request_observation(
OPENAI_PROTOCOL => {
let semantics = codex_responses_request_semantics_with_turn_metadata(
body,
context.get("turn_metadata").and_then(Value::as_str),
crate::openai::context_turn_metadata(body, context),
previous_reasoning_effort_override,
);
RequestObservation {
@@ -265,8 +265,7 @@ impl ProviderAdmin for OpenAiAdminProvider {
}
fn plan_type_display(&self, plan_type: &str) -> String {
// Pro 系列按套餐类型区分展示,其他套餐遵循官方 KnownPlan::display_name
// 只映射展示名称,原始套餐值与未知套餐保持不变
// Pro 三档沿用管理端短名,其余已知套餐使用 Codex /status 的名称
match plan_type.to_ascii_lowercase().as_str() {
"free" => "Free",
"go" => "Go",
@@ -274,16 +273,17 @@ impl ProviderAdmin for OpenAiAdminProvider {
"pro" => "Pro",
"prolite" => "ProLite",
"promax" => "ProMax",
"team" => "Team",
"self_serve_business_prolite" => "Self Serve Business ProLite",
"self_serve_business_usage_based" => "Self Serve Business Usage Based",
"business" => "Business",
"ent26" | "enterprise" | "hc" => "Enterprise",
"team" | "self_serve_business_usage_based" => "Business",
"self_serve_business_prolite" => "Business Premium",
"business" | "ent26" | "enterprise" | "hc" | "enterprise_cbp_usage_based" => {
"Enterprise"
}
"enterprise_cbp_automation" => "Enterprise (Automation)",
"enterprise_cbp_usage_based" => "Enterprise CBP Usage Based",
"edu" | "education" => "Edu",
"edu_plus" => "Edu Plus",
"edu_pro" => "Edu Pro",
"sci" => "Academic Researchers",
"sci_plus" => "Academic Researchers Plus",
_ => plan_type,
}
.to_owned()
@@ -33,7 +33,7 @@ use crate::transport::{CodexBackendClient, CodexCatalogModel, CodexRequestContex
const MAX_RESPONSE_ETAG_BYTES: usize = 256;
const ACCOUNT_CATALOG_CACHE_TTL: Duration = Duration::from_secs(5 * 60);
const CATALOG_REFRESH_AFTER: Duration = Duration::from_secs(30 * 60);
const CATALOG_REFRESH_AFTER: Duration = Duration::from_hours(1);
const MAX_ACCOUNT_CATALOG_MODELS: usize = 2_048;
const MODEL_CATALOG_TIMEOUT: Duration = Duration::from_secs(15);
@@ -137,14 +137,31 @@ impl CatalogContent {
}
}
#[derive(Clone)]
struct AccountEntry {
observed_at: SystemTime,
content: Arc<CatalogContent>,
etag: Option<String>,
// 目录返回不同版本时,触发这次查询的标记只用于去重
trigger_etag: Option<String>,
// 响应只确认这份目录的刷新期限,正文观测时间仍用于并发发布和持久化
etag_confirmed_at: std::sync::Mutex<Option<tokio::time::Instant>>,
}
type Entries = BTreeMap<CodexCatalogScope, AccountEntry>;
impl AccountEntry {
fn recognizes_etag(&self, etag: &str) -> bool {
self.etag.as_deref() == Some(etag) || self.trigger_etag.as_deref() == Some(etag)
}
fn is_fresh(&self, now: SystemTime) -> bool {
now.duration_since(self.observed_at)
.is_ok_and(|age| age < CATALOG_REFRESH_AFTER)
|| self.etag_confirmed_at.lock().is_ok_and(|confirmed| {
confirmed.is_some_and(|at| at.elapsed() < CATALOG_REFRESH_AFTER)
})
}
}
type Entries = BTreeMap<CodexCatalogScope, Arc<AccountEntry>>;
pub struct CodexCredentialCatalogSnapshot {
models: Vec<CodexCatalogModel>,
@@ -551,7 +568,7 @@ impl CodexCredentialCatalogService {
revision: account.revision(),
plan: account.plan_type().map(str::to_owned),
observed_at,
etag: etag.clone().or(fetched.etag),
etag: fetched.etag.or_else(|| etag.clone()),
};
if !self
.repository
@@ -577,7 +594,9 @@ impl CodexCredentialCatalogService {
AccountEntry {
observed_at,
content,
trigger_etag: etag.filter(|tag| Some(tag) != observed.etag.as_ref()),
etag: observed.etag,
etag_confirmed_at: Default::default(),
},
))
}
@@ -37,11 +37,13 @@ impl CodexCredentialCatalogService {
};
entries.insert(
scope,
AccountEntry {
Arc::new(AccountEntry {
observed_at: a.observed_at,
content: content.clone(),
etag: a.etag,
},
trigger_etag: None,
etag_confirmed_at: Default::default(),
}),
);
}
}
@@ -119,15 +121,21 @@ impl CodexCredentialCatalogService {
.cache
.write()
.map_err(|_| CodexCredentialCatalogError::Cache)?;
if state.pending.get(&scope).map(String::as_str) == Some(etag)
|| !state.pending.contains_key(&scope)
&& state
.snapshot
.as_ref()
.and_then(|s| s.entries.get(&scope))
.and_then(|e| e.etag.as_deref())
== Some(etag)
let pending = state.pending.get(&scope);
if pending.is_some_and(|tag| tag == etag) {
return Ok(false);
}
if let Some(entry) = state.snapshot.as_ref().and_then(|s| s.entries.get(&scope))
&& entry.recognizes_etag(etag)
{
// 已收到变更时,迟到的旧标记不能覆盖待刷新版本
if pending.is_none() && entry.etag.as_deref() == Some(etag) {
let mut confirmed_at = entry
.etag_confirmed_at
.lock()
.map_err(|_| CodexCredentialCatalogError::Cache)?;
*confirmed_at = Some(tokio::time::Instant::now());
}
return Ok(false);
}
state.pending.insert(scope, etag.to_owned());
@@ -166,7 +174,7 @@ impl CodexCredentialCatalogService {
.get(&scope)
.is_none_or(|old| old.observed_at < entry.observed_at)
{
entries.insert(scope, entry);
entries.insert(scope, Arc::new(entry));
}
}
self.publish(revision, entries)?;
@@ -205,7 +213,7 @@ impl CodexCredentialCatalogService {
return true;
};
// 发布其他账号时保留通知,只有该账号更新的观测才能确认 ETag
entry.etag.as_deref() != Some(tag)
!entry.recognizes_etag(tag)
|| old
.as_ref()
.and_then(|s| s.entries.get(scope))
@@ -278,10 +286,7 @@ impl CodexCredentialCatalogService {
.into_iter()
.filter(|(scope, _)| {
pending.contains_key(scope)
|| !entries.get(scope).is_some_and(|e| {
now.duration_since(e.observed_at)
.is_ok_and(|age| age < CATALOG_REFRESH_AFTER)
})
|| !entries.get(scope).is_some_and(|entry| entry.is_fresh(now))
})
.collect::<Vec<_>>();
if due.is_empty() {
@@ -434,10 +434,6 @@ pub(super) struct OpenAiSessionState {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(super) oauth_identity: Option<String>,
pub(super) conversation_id: Option<String>,
#[serde(default)]
pub(super) turn_state: Option<String>,
#[serde(default)]
pub(super) client_turn_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub(super) reasoning_effort_override: Option<String>,
pub(super) continuation_scope: OpenAiContinuationScope,
@@ -456,20 +452,12 @@ pub(super) struct OpenAiSessionCapture {
pub(super) credential_revision: Option<u64>,
pub(super) oauth_identity: Option<String>,
pub(super) conversation_id: Option<String>,
pub(super) turn_state: Option<String>,
pub(super) client_turn_id: Option<String>,
pub(super) reasoning_effort_override: Option<String>,
pub(super) response_store: bool,
pub(super) oversized_http: bool,
pub(super) continuation_scope: Option<OpenAiContinuationScope>,
}
pub(super) fn same_client_turn(previous: Option<&str>, current: Option<&str>) -> bool {
previous
.zip(current)
.is_some_and(|(previous, current)| !previous.is_empty() && previous == current)
}
pub(super) fn decode_openai_session_state(request: &GenerateRequest) -> Option<OpenAiSessionState> {
request
.provider_session_state(PROVIDER_NAME)
@@ -505,8 +493,6 @@ fn encode_openai_session_capture(
credential_revision: capture.credential_revision,
oauth_identity: capture.oauth_identity.clone(),
conversation_id: capture.conversation_id.clone(),
turn_state: capture.turn_state.clone(),
client_turn_id: capture.client_turn_id.clone(),
reasoning_effort_override: capture.reasoning_effort_override.clone(),
continuation_scope,
})
@@ -938,7 +924,6 @@ pub(super) fn cold_response_stream(response: ColdResponse) -> EventStream {
} else {
OpenAiContinuationScope::ReplayRequired
});
capture.turn_state = response.turn_state.clone().or(capture.turn_state.clone());
}
let mut observation_state = OpenAiResponseObservationState::from_backend_response(
&response,
@@ -1070,7 +1055,6 @@ pub(super) fn cold_response_stream(response: ColdResponse) -> EventStream {
};
let metadata_merge = merge_response_metadata_updates(
response_metadata_updates.as_ref(),
&mut session_capture,
&mut observation_state,
)
.await;
@@ -1148,7 +1132,6 @@ pub(super) fn cold_response_stream(response: ColdResponse) -> EventStream {
};
let metadata_merge = merge_response_metadata_updates(
response_metadata_updates.as_ref(),
&mut session_capture,
&mut observation_state,
)
.await;
@@ -1354,7 +1337,6 @@ pub(super) fn cold_response_stream(response: ColdResponse) -> EventStream {
}
let metadata_changed = merge_response_metadata_updates(
response_metadata_updates.as_ref(),
&mut session_capture,
&mut observation_state,
)
.await
@@ -1417,12 +1399,8 @@ pub(super) fn cold_response_stream(response: ColdResponse) -> EventStream {
async fn merge_response_metadata_updates(
updates: Option<&CodexResponseMetadataUpdates>,
session_capture: &mut Option<OpenAiSessionCapture>,
observation_state: &mut OpenAiResponseObservationState,
) -> Option<bool> {
let turn_state = updates?.lock().await.turn_state.take()?;
if let Some(capture) = session_capture.as_mut() {
capture.turn_state = Some(turn_state.clone());
}
Some(observation_state.merge_client_header("x-codex-turn-state", &turn_state))
}
@@ -86,7 +86,7 @@ use crate::transport::protocol::responses::{
};
use crate::transport::request::{
CodexRequestEncodeError, RequestAccountScope, align_structured_location_fields,
clear_request_turn_state, encode_generate_request, scope_request_to_account,
encode_generate_request, scope_request_to_account,
};
use crate::transport::session::CodexSessionIdentity;
use crate::transport::usage::normalize_service_tier;
@@ -240,19 +240,6 @@ impl CodexProvider {
if let Some(identity) = &self.session_identity {
identity.prepare_local_conversation(&mut upstream);
}
if let Some(previous_session) = previous_session.as_ref() {
if same_client_turn(
previous_session.client_turn_id.as_deref(),
upstream.client_turn_id.as_deref(),
) {
upstream.turn_state = upstream
.turn_state
.take()
.or_else(|| previous_session.turn_state.clone());
} else {
clear_request_turn_state(&mut upstream);
}
}
let session_affinity =
derive_codex_session_affinity(&upstream, context.client_api_key_ref());
let cyber_policy_session_key =
@@ -1144,8 +1131,6 @@ impl CodexProvider {
)
.then_some(lease.account().revision().get()),
conversation_id: upstream_request.local_conversation_id.clone(),
turn_state: upstream_request.turn_state.clone(),
client_turn_id: upstream_request.client_turn_id.clone(),
reasoning_effort_override: upstream_request
.semantics(
previous_session
@@ -701,8 +701,6 @@ pub(super) fn codex_request_context<'a>(
request_id,
turn_state: request.turn_state.as_deref(),
turn_metadata: request.turn_metadata.as_deref(),
beta_features: request.beta_features.as_deref(),
include_timing_metrics: request.include_timing_metrics.as_deref(),
version: request.version.as_deref(),
codex_window_id: request.codex_window_id.as_deref(),
parent_thread_id: request.parent_thread_id.as_deref(),
@@ -711,7 +709,6 @@ pub(super) fn codex_request_context<'a>(
session_id: request.client_session_id.as_deref(),
thread_id: request.client_thread_id.as_deref(),
client_request_id: request.client_request_id.as_deref(),
turn_id: request.client_turn_id.as_deref(),
account_selection,
}
}
@@ -22,7 +22,7 @@ pub(crate) fn follows_session_with_headers(
}
gateway_protocol::openai::codex_responses_request_semantics_with_turn_metadata(
body,
metadata.or_else(|| context.get("turn_metadata").and_then(Value::as_str)),
metadata.or_else(|| gateway_protocol::openai::context_turn_metadata(body, context)),
None,
)
.subagent_kind
@@ -472,10 +472,6 @@ pub struct CodexRequestContext<'a> {
pub turn_state: Option<&'a str>,
/// 客户端 turn metadata;其中 installation ID 已按当前账号处理
pub turn_metadata: Option<&'a str>,
/// x-codex-beta-features 头值
pub beta_features: Option<&'a str>,
/// x-responsesapi-include-timing-metrics 头值
pub include_timing_metrics: Option<&'a str>,
/// 下游 `version` 扩展头;存在时上游值由 Desktop 版本画像统一生成
pub version: Option<&'a str>,
/// 客户端 window ID
@@ -492,8 +488,6 @@ pub struct CodexRequestContext<'a> {
pub thread_id: Option<&'a str>,
/// 客户端逻辑 request ID;缺失时使用代理请求 ID
pub client_request_id: Option<&'a str>,
/// 客户端 turn ID
pub turn_id: Option<&'a str>,
/// 账号亲和选择结果;仅用于结构化遥测,不参与 transport 决策
pub account_selection: CodexAccountSelectionTelemetry<'a>,
}
@@ -514,8 +508,6 @@ impl<'a> CodexRequestContext<'a> {
request_id,
turn_state: None,
turn_metadata: None,
beta_features: None,
include_timing_metrics: None,
version: None,
codex_window_id: None,
parent_thread_id: None,
@@ -524,7 +516,6 @@ impl<'a> CodexRequestContext<'a> {
session_id: None,
thread_id: None,
client_request_id: None,
turn_id: None,
account_selection: CodexAccountSelectionTelemetry::NONE,
}
}
@@ -211,11 +211,6 @@ impl CodexBackendClient {
("x-codex-window-id", context.codex_window_id),
("x-codex-turn-state", context.turn_state),
("x-codex-turn-metadata", context.turn_metadata),
("x-codex-beta-features", context.beta_features),
(
"x-responsesapi-include-timing-metrics",
context.include_timing_metrics,
),
("x-codex-parent-thread-id", context.parent_thread_id),
(
X_OPENAI_MEMGEN_REQUEST_HEADER,
@@ -50,8 +50,6 @@ pub struct CodexResponsesRequest {
pub client_thread_id: Option<String>,
/// 客户端 request ID,仅保留在受控本地上下文
pub client_request_id: Option<String>,
/// 客户端 turn ID,仅保留在受控本地上下文
pub client_turn_id: Option<String>,
/// 连接池和 affinity 使用的本地会话身份,不发送上游
pub local_conversation_id: Option<String>,
/// 变体身份键
@@ -70,12 +68,10 @@ pub struct CodexResponsesRequest {
pub turn_state: Option<String>,
/// turn metadata 透传头
pub turn_metadata: Option<String>,
/// beta features 透传头
pub beta_features: Option<String>,
/// 实际入站为 WS 帧时,观测优先使用本帧的轮次元数据
pub(crate) websocket_frame: bool,
/// 下游 `version` 扩展头;存在时上游值由 Desktop 版本画像统一生成
pub version: Option<String>,
/// timing metrics 透传头
pub include_timing_metrics: Option<String>,
/// Responses Lite 请求语义;HTTP 使用 header,WebSocket 使用 client metadata 投影
pub responses_lite: Option<String>,
/// Memory consolidation 请求语义;HTTP 与 WebSocket opening 均使用 header
@@ -605,7 +601,6 @@ impl CodexResponsesRequest {
client_account_follow_only: false,
client_thread_id: None,
client_request_id: None,
client_turn_id: None,
local_conversation_id: None,
variant_identity: None,
client_ip: None,
@@ -615,9 +610,8 @@ impl CodexResponsesRequest {
force_http_sse: false,
turn_state: None,
turn_metadata: None,
beta_features: None,
websocket_frame: false,
version: None,
include_timing_metrics: None,
responses_lite: None,
memgen_request: None,
codex_window_id: None,
@@ -774,7 +768,11 @@ impl CodexResponsesRequest {
) -> CodexRequestSemantics {
codex_responses_request_semantics_with_turn_metadata(
self.body(),
self.turn_metadata.as_deref(),
gateway_protocol::openai::observed_turn_metadata(
self.body(),
self.turn_metadata.as_deref(),
self.websocket_frame,
),
previous_reasoning_effort_override,
)
}
@@ -22,7 +22,6 @@ use crate::transport::protocol::responses::{
};
pub(crate) const PASSTHROUGH_HEADERS_CONTEXT_KEY: &str = "opaque_request_headers";
const TURN_ID_CLIENT_METADATA_KEY: &str = "turn_id";
const THREAD_SPAWN_SUBAGENT_KIND: &str = "thread_spawn";
const THREAD_SPAWN_CONVERSATION_PREFIX: &str = "thread-spawn:";
const ENVIRONMENT_CONTEXT_CONTENT_KIND: &str = "environments.environment_context";
@@ -256,14 +255,11 @@ fn extract_request_context(request: &mut CodexResponsesRequest) {
let context = ExtractedRequestContext::from_body(request.body());
request.turn_state = context.turn_state;
request.turn_metadata = context.turn_metadata;
request.beta_features = context.beta_features;
request.version = context.version;
request.include_timing_metrics = context.include_timing_metrics;
request.codex_window_id = context.codex_window_id;
request.parent_thread_id = context.parent_thread_id;
request.client_conversation_id = context.conversation_id;
request.client_request_id = context.client_request_id;
request.client_turn_id = context.turn_id;
request.responses_lite = context.responses_lite;
request.memgen_request = context.memgen_request;
}
@@ -271,14 +267,11 @@ fn extract_request_context(request: &mut CodexResponsesRequest) {
struct ExtractedRequestContext {
turn_state: Option<String>,
turn_metadata: Option<String>,
beta_features: Option<String>,
version: Option<String>,
include_timing_metrics: Option<String>,
codex_window_id: Option<String>,
parent_thread_id: Option<String>,
conversation_id: Option<String>,
client_request_id: Option<String>,
turn_id: Option<String>,
responses_lite: Option<String>,
memgen_request: Option<String>,
}
@@ -287,26 +280,18 @@ impl ExtractedRequestContext {
fn from_body(body: &Map<String, Value>) -> Self {
let client_metadata = body.get("client_metadata").and_then(Value::as_object);
Self {
// 官方 downstream WebSocket 无法逐帧更新 HTTP header,因此把
// response.metadata 返回的 turn state 放回下一帧 client_metadata
// Provider 仍会在账号/turn 归属确定后决定是否允许复用该状态
// 下游 WS 在每个 response.create 的 client_metadata 回传本轮路由状态
turn_state: body_string(body, "turnState").or_else(|| {
client_metadata.and_then(|metadata| {
string_value(metadata.get(X_CODEX_TURN_STATE_CLIENT_METADATA_KEY))
})
}),
turn_metadata: body_string(body, "turnMetadata"),
beta_features: body_string(body, "betaFeatures"),
version: body_string(body, "version"),
include_timing_metrics: body_string(body, "includeTimingMetrics"),
codex_window_id: body_string(body, "codexWindowId"),
parent_thread_id: body_string(body, "parentThreadId"),
conversation_id: body_string(body, "conversation_id"),
client_request_id: body_string(body, "x-client-request-id"),
turn_id: body_string(body, "turn_id").or_else(|| {
client_metadata
.and_then(|metadata| string_value(metadata.get(TURN_ID_CLIENT_METADATA_KEY)))
}),
// Responses Lite 在 WebSocket body 中的这个键是官方 header 投影,
// 不是普通上下文字段的 metadata 回退
responses_lite: client_metadata.and_then(|metadata| {
@@ -452,8 +437,8 @@ fn normalize_conversation_anchor_text(text: &str) -> String {
rest.to_owned()
}
/// 已确认换轮或换号时,各 wire 入口同步清理原有路由 token
pub(crate) fn clear_request_turn_state(request: &mut CodexResponsesRequest) {
/// 明确换号时,同步清除请求头与正文中的原账号路由 token
fn clear_request_turn_state(request: &mut CodexResponsesRequest) {
request.turn_state = None;
request.passthrough_headers.remove("x-codex-turn-state");
for key in TURN_STATE_KEYS {
@@ -745,20 +730,24 @@ fn replace_metadata_field(metadata: &mut Map<String, Value>, key: &str, value: O
// 请求头的场景)
fn apply_protocol_context(request: &mut CodexResponsesRequest, context: &Map<String, Value>) {
request.passthrough_headers = decode_passthrough_headers(context);
request.turn_state =
context_string(context, "turn_state").or_else(|| request.turn_state.take());
request.websocket_frame = context
.get(gateway_protocol::openai::WEBSOCKET_FRAME_CONTEXT_KEY)
.and_then(Value::as_bool)
== Some(true);
request.turn_metadata =
context_string(context, "turn_metadata").or_else(|| request.turn_metadata.take());
request.beta_features =
context_string(context, "beta_features").or_else(|| request.beta_features.take());
request.version = context_string(context, "version").or_else(|| request.version.take());
request.include_timing_metrics = context_string(context, "include_timing_metrics")
.or_else(|| request.include_timing_metrics.take());
request.codex_window_id =
context_string(context, "codex_window_id").or_else(|| request.codex_window_id.take());
request.downstream_websocket_connection_id =
context_string(context, "downstream_websocket_connection_id")
.or_else(|| request.downstream_websocket_connection_id.take());
if request.downstream_websocket_connection_id.is_some() && request.turn_state.is_some() {
// 当前帧的路由状态优先于握手值,原始握手头也不能覆盖出站投影
request.passthrough_headers.remove("x-codex-turn-state");
} else if let Some(state) = context_string(context, "turn_state") {
request.turn_state = Some(state);
}
request.parent_thread_id =
context_string(context, "parent_thread_id").or_else(|| request.parent_thread_id.take());
let prompt_cache_key = request.prompt_cache_key().map(ToOwned::to_owned);
@@ -773,8 +762,6 @@ fn apply_protocol_context(request: &mut CodexResponsesRequest, context: &Map<Str
request.client_thread_id = gateway_protocol::openai::codex_thread_id(request.body(), context);
request.client_request_id =
context_string(context, "client_request_id").or_else(|| request.client_request_id.take());
request.client_turn_id =
context_string(context, "turn_id").or_else(|| request.client_turn_id.take());
request.responses_lite =
context_string(context, "responses_lite").or_else(|| request.responses_lite.take());
request.memgen_request =
@@ -69,7 +69,7 @@ const COMPLETED_SESSION_SSE: &str = concat!(
);
#[tokio::test]
async fn plan_display_should_distinguish_pro_tiers_and_preserve_other_official_names() {
async fn plan_display_uses_pro_short_names_and_codex_status_labels_for_other_known_plans() {
let config = valid_config();
let bundle = provider_openai::initialize(
config.config.clone(),
@@ -86,25 +86,25 @@ async fn plan_display_should_distinguish_pro_tiers_and_preserve_other_official_n
("free", "Free"),
("go", "Go"),
("plus", "Plus"),
("team", "Team"),
("self_serve_business_prolite", "Self Serve Business ProLite"),
(
"self_serve_business_usage_based",
"Self Serve Business Usage Based",
),
("business", "Business"),
("team", "Business"),
("self_serve_business_prolite", "Business Premium"),
("self_serve_business_usage_based", "Business"),
("business", "Enterprise"),
("ent26", "Enterprise"),
("enterprise", "Enterprise"),
("hc", "Enterprise"),
("enterprise_cbp_automation", "Enterprise (Automation)"),
("enterprise_cbp_usage_based", "Enterprise CBP Usage Based"),
("enterprise_cbp_usage_based", "Enterprise"),
("edu", "Edu"),
("education", "Edu"),
("edu_plus", "Edu Plus"),
("edu_pro", "Edu Pro"),
("future_plan", "future_plan"),
("sci", "Academic Researchers"),
("sci_plus", "Academic Researchers Plus"),
("SCI_PLUS", "Academic Researchers Plus"),
("Future_Plan", "Future_Plan"),
] {
assert_eq!(admin.plan_type_display(raw), display);
assert_eq!(admin.plan_type_display(raw), display, "{raw}");
}
}
@@ -738,6 +738,108 @@ async fn invalidation_queues_background_refresh_without_an_upstream_etag() {
);
}
#[tokio::test]
async fn matching_etag_renews_only_its_account_until_the_next_change_or_expiry() {
use gateway_core::account::AccountCatalogObservation;
use std::time::{Duration, SystemTime};
let store = Arc::new(MemoryAccountStore::default());
let active = seed_account(&store, "acct_active").await;
let idle = seed_account(&store, "acct_idle").await;
let document = [&[0_u8][..], OFFICIAL_FIXTURE].concat();
let old_tag = r#""v1""#;
let new_tag = r#""v2""#;
let observed_at = SystemTime::now() - Duration::from_mins(61);
for account in [&active, &idle] {
assert!(
store
.save_account_catalog(
&AccountCatalogObservation {
account_id: account.id().clone(),
revision: account.revision(),
plan: account.plan_type().map(str::to_owned),
observed_at,
etag: Some(old_tag.to_owned()),
},
&document
)
.await
.unwrap()
);
}
let server = MockServer::start().await;
for account in [&active, &idle] {
Mock::given(method("GET"))
.and(path("/codex/models"))
.and(header(
"chatgpt-account-id",
format!("chatgpt-{}", account.id()),
))
.respond_with(
ResponseTemplate::new(200)
.insert_header("etag", old_tag)
.set_body_raw(OFFICIAL_FIXTURE, "application/json"),
)
.expect(1)
.mount(&server)
.await;
}
let service = service_with_catalog_cache(&store, server.uri(), catalog_cache());
service.restore().await.unwrap();
assert!(!service.observe_response_etag(&active, old_tag).unwrap());
service.refresh_catalogs().await.unwrap();
let requests = server.received_requests().await.unwrap();
assert_eq!(requests.len(), 1);
assert_eq!(
requests[0].headers["chatgpt-account-id"],
"chatgpt-acct_idle"
);
tokio::time::pause();
tokio::time::advance(Duration::from_mins(59)).await;
service.refresh_catalogs().await.unwrap();
assert_eq!(server.received_requests().await.unwrap().len(), 1);
tokio::time::advance(Duration::from_mins(1)).await;
tokio::time::resume();
service.refresh_catalogs().await.unwrap();
server.verify().await;
server.reset().await;
Mock::given(method("GET"))
.and(path("/codex/models"))
.and(header("chatgpt-account-id", "chatgpt-acct_active"))
.respond_with(
ResponseTemplate::new(200)
.insert_header("etag", new_tag)
.set_body_json(
serde_json::json!({"models":[{"slug":"active-only","display_name":"Active"}]}),
),
)
.expect(1)
.mount(&server)
.await;
assert!(!service.observe_response_etag(&active, old_tag).unwrap());
assert!(
service
.observe_response_etag(&active, "change-hint")
.unwrap()
);
assert!(!service.observe_response_etag(&active, old_tag).unwrap());
service.refresh_catalogs().await.unwrap();
assert!(
!service
.observe_response_etag(&active, "change-hint")
.unwrap()
);
assert!(!service.observe_response_etag(&active, new_tag).unwrap());
service.refresh_catalogs().await.unwrap();
assert_eq!(
service.cached_account_models(&active).unwrap().unwrap(),
["active-only"]
);
server.verify().await;
}
#[tokio::test]
async fn simultaneous_periodic_refreshes_share_the_completed_scan() {
let store = Arc::new(MemoryAccountStore::default());
@@ -48,13 +48,15 @@ fn isolation_payload() -> ProtocolPayload {
turn_metadata.insert("parent_response_id".to_owned(), json!("client-correlation"));
turn_metadata.insert("workspace".to_owned(), json!("/工作区"));
turn_metadata.insert("future".to_owned(), json!({"traceparent":"business-value"}));
let mut frame_metadata = turn_metadata.clone();
frame_metadata.insert("tool_namespaces_info".into(), json!({"workspace":{}}));
let mut body = json!({
"model": "gpt-5.4",
"input": isolation_history(),
"client_metadata": {
"parent_response_id": "resp_parent_old",
"guardian_credits_requested": "true",
"x-codex-turn-metadata": Value::Object(turn_metadata.clone()).to_string(),
"x-codex-turn-metadata": Value::Object(frame_metadata).to_string(),
"turnMetadata": turn_metadata,
"mcp_attribution": r#"{"status":"complete","sources":[]}"#
}
@@ -86,6 +88,10 @@ fn isolation_payload() -> ProtocolPayload {
ProtocolPayload::json_object("openai", body.as_object().unwrap().clone())
.unwrap()
.with_context(Map::from_iter([
(
gateway_protocol::openai::WEBSOCKET_FRAME_CONTEXT_KEY.into(),
json!(true),
),
("opaque_request_headers".to_owned(), json!(headers)),
(
"turn_metadata".to_owned(),
@@ -155,7 +161,6 @@ fn assert_isolated_request(
&body["turnMetadata"],
&body["turn_metadata"],
&body["client_metadata"]["turnMetadata"],
&body["client_metadata"]["x-codex-turn-metadata"],
] {
let actual = match metadata {
Value::String(raw) => serde_json::from_str(raw).unwrap(),
@@ -163,6 +168,15 @@ fn assert_isolated_request(
};
assert_eq!(actual, Value::Object(expected_turn_metadata.clone()));
}
let mut expected_frame_metadata = expected_turn_metadata.clone();
expected_frame_metadata.insert("tool_namespaces_info".into(), json!({"workspace":{}}));
let frame = body["client_metadata"]["x-codex-turn-metadata"]
.as_str()
.unwrap();
assert_eq!(
serde_json::from_str::<Value>(frame).unwrap(),
Value::Object(expected_frame_metadata)
);
let header = headers["x-codex-turn-metadata"].to_str().unwrap();
assert!(header.is_ascii());
assert_eq!(
@@ -2053,8 +2053,6 @@ async fn provider_should_override_unclassified_time_contexts_over_websocket() {
}
async fn capture_turn_state_request(
request_id: &str,
previous_turn_id: Option<&str>,
current_turn_id: Option<&str>,
client_turn_state: Option<&str>,
) -> wiremock::Request {
@@ -2072,18 +2070,19 @@ async fn capture_turn_state_request(
.expect(1)
.mount(&server)
.await;
let mut session_state = Map::from_iter([
let session_state = Map::from_iter([
("account_id".to_owned(), json!(account_id)),
("conversation_id".to_owned(), json!("conversation")),
("turn_state".to_owned(), json!("previous-turn-state")),
("client_turn_id".to_owned(), json!("turn-same")),
("continuation_scope".to_owned(), json!("persisted")),
]);
if let Some(previous_turn_id) = previous_turn_id {
session_state.insert("client_turn_id".to_owned(), json!(previous_turn_id));
}
let mut protocol_context = Map::from_iter([("use_websocket".to_owned(), json!(false))]);
if let Some(current_turn_id) = current_turn_id {
protocol_context.insert("turn_id".to_owned(), json!(current_turn_id));
protocol_context.insert(
"turn_metadata".to_owned(),
Value::String(json!({"turn_id": current_turn_id}).to_string()),
);
}
if let Some(client_turn_state) = client_turn_state {
protocol_context.insert("turn_state".to_owned(), json!(client_turn_state));
@@ -2095,6 +2094,7 @@ async fn capture_turn_state_request(
let mut body = Map::from_iter([
("model".to_owned(), json!("gpt-5.4")),
("input".to_owned(), json!("current input")),
("previous_response_id".to_owned(), json!("resp_previous")),
("client_metadata".to_owned(), json!({"custom":"preserved"})),
]);
if let Some(state) = client_turn_state {
@@ -2119,7 +2119,7 @@ async fn capture_turn_state_request(
let mut stream = provider_with_base_url(&store, server.uri())
.execute(
planned_request("openai", operation),
context(request_id, CancellationToken::new()),
context("req_client_turn_state", CancellationToken::new()),
)
.await
.expect("prepare turn-state provider stream");
@@ -7093,78 +7093,29 @@ async fn missing_affinity_full_request_should_preserve_client_turn_state() {
}
#[tokio::test]
async fn matching_turn_id_should_restore_previous_turn_state() {
let request = capture_turn_state_request(
"req_restore_same_turn_state",
Some("turn-same"),
Some("turn-same"),
None,
)
.await;
assert_eq!(
captured_header_values(&request, "x-codex-turn-state"),
vec![b"previous-turn-state".to_vec()]
);
}
#[tokio::test]
async fn matching_turn_id_should_prefer_an_explicit_client_echo_over_saved_provider_state() {
let request = capture_turn_state_request(
"req_use_client_turn_state",
Some("turn-same"),
Some("turn-same"),
Some("client-turn-state"),
)
.await;
assert_eq!(
captured_header_values(&request, "x-codex-turn-state"),
vec![b"client-turn-state".to_vec()]
);
let body = captured_request_body(&request);
for key in ["turnState", "turn_state", "x-codex-turn-state"] {
assert_eq!(body[key], "client-turn-state");
assert_eq!(body["client_metadata"][key], "client-turn-state");
}
}
#[tokio::test]
async fn new_or_unidentified_turn_should_not_restore_previous_turn_state() {
for (request_id, previous_turn_id, current_turn_id, client_turn_state) in [
(
"req_new_turn_state",
Some("turn-old"),
Some("turn-new"),
Some("stale-client-turn-state"),
),
(
"req_unidentified_turn_state",
None,
Some("turn-new"),
Some("stale-client-turn-state"),
),
(
"req_missing_current_turn_state",
Some("turn-old"),
None,
Some("stale-client-turn-state"),
),
async fn same_account_continuation_forwards_only_the_current_request_turn_state() {
// 旧版会话中可能仍有保存的轮次和 token
for (turn, supplied) in [
(Some("turn-same"), None),
(Some("turn-same"), Some("client-turn-state")),
(Some("turn-new"), Some("client-turn-state")),
(None, Some("client-turn-state")),
] {
let request = capture_turn_state_request(
request_id,
previous_turn_id,
current_turn_id,
client_turn_state,
)
.await;
assert!(captured_header_values(&request, "x-codex-turn-state").is_empty());
let request = capture_turn_state_request(turn, supplied).await;
let headers = captured_header_values(&request, "x-codex-turn-state");
assert_eq!(
headers,
supplied
.map(|value| value.as_bytes())
.into_iter()
.collect::<Vec<_>>()
);
let body = captured_request_body(&request);
for key in ["turnState", "turn_state", "x-codex-turn-state"] {
assert!(body.get(key).is_none(), "stale body state: {key}");
assert!(
body["client_metadata"].get(key).is_none(),
"stale metadata state: {key}"
assert_eq!(body.get(key).and_then(Value::as_str), supplied);
assert_eq!(
body["client_metadata"].get(key).and_then(Value::as_str),
supplied
);
}
assert_eq!(body["input"][0]["content"][0]["text"], "current input");
@@ -2,6 +2,45 @@
use super::*;
#[tokio::test]
async fn websocket_body_fields_stay_in_the_body_when_using_http_upstream() {
let frame = r#"{"request_kind":"turn","tool_namespaces_info":{"workspace":{}}}"#;
let body = json!({
"model": "gpt-5.4", "input": "hello",
"client_metadata": {"x-codex-turn-metadata": frame},
"betaFeatures": "only-in-body", "includeTimingMetrics": "true"
});
let sent = capture_scoped_http_request(
"req_frame_only",
"acct_scope_same",
"acct_scope_same",
body.as_object().unwrap().clone(),
Map::from_iter([(
gateway_protocol::openai::WEBSOCKET_FRAME_CONTEXT_KEY.into(),
json!(true),
)]),
)
.await;
for header in [
"x-codex-turn-metadata",
"x-codex-beta-features",
"x-responsesapi-include-timing-metrics",
] {
assert!(!sent.headers.contains_key(header), "{header}");
}
let sent_body = captured_request_body(&sent);
let sent_frame = sent_body["client_metadata"]["x-codex-turn-metadata"]
.as_str()
.unwrap();
assert_eq!(
serde_json::from_str::<Value>(sent_frame).unwrap(),
serde_json::from_str::<Value>(frame).unwrap()
);
for key in ["betaFeatures", "includeTimingMetrics"] {
assert_eq!(sent_body[key], body[key]);
}
}
#[tokio::test]
async fn responses_options_follow_the_selected_upstream_on_both_transports() {
let oauth_omissions = json!({
@@ -431,8 +431,6 @@ fn context() -> CodexRequestContext<'static> {
request_id: "req_catalog",
turn_state: None,
turn_metadata: None,
beta_features: None,
include_timing_metrics: None,
version: None,
codex_window_id: None,
parent_thread_id: None,
@@ -441,7 +439,6 @@ fn context() -> CodexRequestContext<'static> {
session_id: None,
thread_id: None,
client_request_id: None,
turn_id: None,
account_selection: Default::default(),
}
}
@@ -34,8 +34,6 @@ fn request_context_debug_should_redact_all_identity_material() {
request_id: "req_safe",
turn_state: Some("turn-secret-marker"),
turn_metadata: Some("metadata-secret-marker"),
beta_features: None,
include_timing_metrics: None,
version: None,
codex_window_id: None,
parent_thread_id: None,
@@ -44,7 +42,6 @@ fn request_context_debug_should_redact_all_identity_material() {
session_id: None,
thread_id: None,
client_request_id: None,
turn_id: None,
account_selection: Default::default(),
};
let debug = format!("{context:?}");
@@ -148,8 +148,15 @@ async fn backend_websocket_should_forward_context_headers_and_preserve_payload_f
.expect("send terminal event");
payload
});
let mut request =
codex_request_with_prompt_cache_key("gpt-test", "be brief", Vec::new(), "client-thread");
let mut body = codex_request_body("gpt-test", "be brief", Vec::new());
body.insert("prompt_cache_key".into(), json!("client-thread"));
let mut request = encode_request_with_headers(
body,
&[
("x-codex-beta-features", "feature-a"),
("x-responsesapi-include-timing-metrics", "true"),
],
);
request.use_websocket = true;
request.responses_lite = Some("true".to_owned());
request.memgen_request = Some("true".to_owned());
@@ -179,8 +186,6 @@ async fn backend_websocket_should_forward_context_headers_and_preserve_payload_f
request_id: "req_ws_security",
turn_state: Some("turn-state"),
turn_metadata: Some("{\"thread_source\":\"subagent\"}"),
beta_features: Some("feature-a"),
include_timing_metrics: Some("true"),
version: Some("26.318.11754"),
codex_window_id: Some("cw_derived"),
parent_thread_id: Some("parent-456"),
@@ -189,7 +194,6 @@ async fn backend_websocket_should_forward_context_headers_and_preserve_payload_f
session_id: Some("cp_derived"),
thread_id: None,
client_request_id: None,
turn_id: None,
account_selection: Default::default(),
},
)
@@ -265,11 +269,18 @@ async fn backend_http_should_send_codex_context_without_browser_headers() {
write_completed_sse_response(&mut stream).await;
request
});
let mut request = codex_request("gpt-test", "", Vec::new());
let mut body = codex_request_body("gpt-test", "", Vec::new());
body.insert("betaFeatures".into(), json!("body-beta"));
body.insert("includeTimingMetrics".into(), json!("body-timing"));
let mut request = encode_request_with_headers(
body,
&[
("x-codex-beta-features", "beta-a"),
("x-responsesapi-include-timing-metrics", "true"),
],
);
request.force_http_sse = true;
request.turn_metadata = Some("turn-meta".to_owned());
request.beta_features = Some("beta-a".to_owned());
request.include_timing_metrics = Some("true".to_owned());
request.version = Some("26.707.51957".to_owned());
request.codex_window_id = Some("cw_1".to_owned());
request.parent_thread_id = Some("parent-1".to_owned());
@@ -297,8 +308,6 @@ async fn backend_http_should_send_codex_context_without_browser_headers() {
request_id: "req_order",
turn_state: Some("turn-state"),
turn_metadata: request.turn_metadata.as_deref(),
beta_features: request.beta_features.as_deref(),
include_timing_metrics: request.include_timing_metrics.as_deref(),
version: request.version.as_deref(),
codex_window_id: request.codex_window_id.as_deref(),
parent_thread_id: request.parent_thread_id.as_deref(),
@@ -307,7 +316,6 @@ async fn backend_http_should_send_codex_context_without_browser_headers() {
session_id: Some("session-1"),
thread_id: None,
client_request_id: None,
turn_id: None,
account_selection: Default::default(),
},
)
@@ -429,11 +437,8 @@ async fn backend_http_should_ignore_unrepresentable_protocol_headers_without_blo
client_request_id: Some("opaque\nclient-request-id"),
session_id: Some("opaque\nsession"),
thread_id: Some("opaque\nthread"),
turn_id: Some("opaque\nturn"),
codex_window_id: Some("opaque\nwindow"),
parent_thread_id: Some("opaque\nparent"),
beta_features: Some("opaque\nbeta"),
include_timing_metrics: Some("opaque\ntiming"),
version: Some("opaque\nversion"),
turn_state: request.turn_state.as_deref(),
turn_metadata: request.turn_metadata.as_deref(),
@@ -130,8 +130,6 @@ async fn codex_backend_client_should_preserve_oversized_error_response() {
request_id: "req_large_error",
turn_state: None,
turn_metadata: None,
beta_features: None,
include_timing_metrics: None,
version: None,
codex_window_id: None,
parent_thread_id: None,
@@ -140,7 +138,6 @@ async fn codex_backend_client_should_preserve_oversized_error_response() {
session_id: None,
thread_id: None,
client_request_id: None,
turn_id: None,
account_selection: Default::default(),
},
)
@@ -231,8 +228,6 @@ async fn codex_backend_client_should_parse_retry_after_from_rate_limit_error_bod
request_id: "req_http_retry_after_body",
turn_state: None,
turn_metadata: None,
beta_features: None,
include_timing_metrics: None,
version: None,
codex_window_id: None,
parent_thread_id: None,
@@ -241,7 +236,6 @@ async fn codex_backend_client_should_parse_retry_after_from_rate_limit_error_bod
session_id: None,
thread_id: None,
client_request_id: None,
turn_id: None,
account_selection: Default::default(),
},
)
@@ -417,8 +411,6 @@ async fn codex_backend_client_should_capture_forwardable_response_metadata() {
request_id: "req_response_metadata",
turn_state: None,
turn_metadata: None,
beta_features: None,
include_timing_metrics: None,
version: None,
codex_window_id: None,
parent_thread_id: None,
@@ -427,7 +419,6 @@ async fn codex_backend_client_should_capture_forwardable_response_metadata() {
session_id: None,
thread_id: None,
client_request_id: None,
turn_id: None,
account_selection: Default::default(),
},
)
@@ -157,8 +157,6 @@ pub(crate) fn request_context<'a>(
request_id,
turn_state: None,
turn_metadata: None,
beta_features: None,
include_timing_metrics: None,
version: None,
codex_window_id: None,
parent_thread_id: None,
@@ -167,7 +165,6 @@ pub(crate) fn request_context<'a>(
session_id: None,
thread_id: None,
client_request_id: None,
turn_id: None,
account_selection: Default::default(),
}
}
@@ -357,6 +354,33 @@ fn codex_request_with_prompt_cache_key(
CodexResponsesRequest::from_body(body)
}
fn encode_request_with_headers(
body: Map<String, Value>,
headers: &[(&str, &str)],
) -> CodexResponsesRequest {
use base64::{Engine as _, engine::general_purpose::STANDARD};
use gateway_core::operation::{GenerateRequest, ProtocolPayload};
use provider_openai::transport::request::encode_generate_request;
let headers: Vec<_> = headers
.iter()
.map(|(name, value)| json!([name, STANDARD.encode(value)]))
.collect();
let model = body["model"].as_str().unwrap().to_owned();
let payload = ProtocolPayload::json_object("openai", body)
.unwrap()
.with_context(Map::from_iter([(
"opaque_request_headers".to_owned(),
json!(headers),
)]));
encode_generate_request(
&GenerateRequest::from_protocol_payload(payload),
&model,
None,
)
.unwrap()
}
fn codex_request_body(
model: impl Into<String>,
instructions: impl Into<String>,
@@ -542,10 +542,39 @@ fn encoder_should_extract_websocket_context_from_client_metadata() {
);
assert_eq!(encoded.client_thread_id.as_deref(), Some("metadata-thread"));
assert_eq!(encoded.turn_state.as_deref(), Some("metadata-turn-state"));
assert_eq!(encoded.client_turn_id.as_deref(), Some("metadata-turn-id"));
assert_eq!(encoded.body().get("client_metadata"), Some(&metadata));
}
#[test]
fn websocket_frame_turn_state_overrides_the_opening_header() {
let payload = ProtocolPayload::json_object(
"openai",
Map::from_iter([
("model".to_owned(), json!("client-model")),
("input".to_owned(), json!("prompt")),
(
"client_metadata".to_owned(),
json!({"x-codex-turn-state": "frame"}),
),
]),
)
.unwrap()
.with_context(Map::from_iter([
(
"downstream_websocket_connection_id".to_owned(),
json!("ws_test"),
),
("turn_state".to_owned(), json!("opening")),
]));
let encoded = encode_generate_request(
&GenerateRequest::from_protocol_payload(payload),
"gpt-test",
None,
)
.unwrap();
assert_eq!(encoded.turn_state.as_deref(), Some("frame"));
}
#[test]
fn header_context_should_win_over_body_topline_aliases() {
let payload = ProtocolPayload::json_object(
@@ -574,10 +603,6 @@ fn header_context_should_win_over_body_topline_aliases() {
"turn_metadata".to_owned(),
Value::String("header-turn-metadata".to_owned()),
),
(
"turn_id".to_owned(),
Value::String("header-turn-id".to_owned()),
),
]));
let request = GenerateRequest::from_protocol_payload(payload);
@@ -588,7 +613,6 @@ fn header_context_should_win_over_body_topline_aliases() {
encoded.turn_metadata.as_deref(),
Some("header-turn-metadata")
);
assert_eq!(encoded.client_turn_id.as_deref(), Some("header-turn-id"));
}
#[test]
@@ -542,8 +542,6 @@ async fn fetch_should_use_wham_usage_headers_only() {
request_id: "req_usage_headers",
turn_state: Some("turn-state"),
turn_metadata: Some("turn-meta"),
beta_features: Some("feature-a"),
include_timing_metrics: Some("true"),
version: Some("26.318.11754"),
codex_window_id: Some("cw_1"),
parent_thread_id: Some("parent-1"),
@@ -552,7 +550,6 @@ async fn fetch_should_use_wham_usage_headers_only() {
session_id: Some("session-1"),
thread_id: Some("thread-1"),
client_request_id: Some("client-request-1"),
turn_id: Some("turn-1"),
account_selection: Default::default(),
})
.await
@@ -943,8 +940,6 @@ fn context() -> CodexRequestContext<'static> {
request_id: "req_usage_limit",
turn_state: None,
turn_metadata: None,
beta_features: None,
include_timing_metrics: None,
version: None,
codex_window_id: None,
parent_thread_id: None,
@@ -953,7 +948,6 @@ fn context() -> CodexRequestContext<'static> {
session_id: None,
thread_id: None,
client_request_id: None,
turn_id: None,
account_selection: Default::default(),
}
}
@@ -51,7 +51,7 @@ async fn official_websocket_wire_fingerprint_should_remain_aligned() {
(opening, websocket_key, frame)
});
let mut request = CodexResponsesRequest::from_body(
let mut request = encode_request_with_headers(
json!({
"model": "gpt-5.5",
"instructions": "be brief",
@@ -70,11 +70,11 @@ async fn official_websocket_wire_fingerprint_should_remain_aligned() {
.as_object()
.expect("request object")
.clone(),
&[("x-codex-beta-features", "feature-a")],
);
request.use_websocket = true;
request.local_conversation_id = Some("conversation-fingerprint".to_owned());
request.turn_metadata = Some(r#"{"kind":"fingerprint"}"#.to_owned());
request.beta_features = Some("feature-a".to_owned());
request.version = Some("26.908.40834".to_owned());
request.codex_window_id = Some("window-fingerprint".to_owned());
let client = CodexBackendClient::new(
@@ -94,7 +94,6 @@ async fn official_websocket_wire_fingerprint_should_remain_aligned() {
response_control: None,
trace: None,
turn_metadata: request.turn_metadata.as_deref(),
beta_features: request.beta_features.as_deref(),
version: request.version.as_deref(),
codex_window_id: request.codex_window_id.as_deref(),
session_id: Some("session-fingerprint"),
@@ -2288,8 +2288,6 @@ async fn codex_backend_client_should_use_websocket_when_previous_response_id_is_
request_id: "req_ws_client",
turn_state: None,
turn_metadata: None,
beta_features: None,
include_timing_metrics: None,
version: None,
codex_window_id: None,
parent_thread_id: None,
@@ -2298,7 +2296,6 @@ async fn codex_backend_client_should_use_websocket_when_previous_response_id_is_
session_id: None,
thread_id: None,
client_request_id: None,
turn_id: None,
account_selection: Default::default(),
},
)
+9 -4
View File
@@ -542,9 +542,13 @@ Images 的 `x-codex-image-turn-id` 和 Desktop 自动 Git 上下文的 `clientUs
续接 response ID、历史 item/call ID、业务正文和未知扩展不参与映射,
该处理减少显式追踪标识的跨账号复用,不保证会话内容或业务 metadata 无法关联
`x-codex-turn-state` 是上游返回的轮次路由 token,同一轮内应原样回传,开始新轮次时清除。
全量请求没有 `previous_response_id` 或缺少本地归属记录时,代理原样保留客户端回传值;
明确换账号或可信续接状态表明不属于同一轮时清除。该 token 不使其他账号状态字段或未知 `previous_response_id` 成为可信续接上下文
`x-codex-turn-metadata` 请求头与 `client_metadata` 内的同名字段分别按账号处理并转发。
WS 握手的轮次元数据头只随首次请求转发,后续帧在正文中携带本轮元数据。网关优先按当前帧识别普通对话和压缩请求。
`x-codex-beta-features` 和 `x-responsesapi-include-timing-metrics` 按原始请求头透传
`x-codex-turn-state` 是上游签发的轮次路由 token。客户端在同一轮原样回传,新轮次省略。
网关转发当前请求提供的值,明确换账号时清除。WS 握手携带的值只用于首次请求,当前帧提供的值优先。
续接 response ID 及其他账号状态的归属独立校验
#### 正文兼容
@@ -1311,7 +1315,8 @@ OpenAI OAuth 账号的 `capabilities.quotaSettingsSupported` 为真。通过 `PO
账号视图和 Dashboard 账号概览中的 `planType` 保留原始套餐值;`planTypeDisplay` 使用 Provider 提供的最终名称,
前端直接展示。OpenAI 的 `prolite`、`pro`、`promax` 分别显示为 `ProLite`、`Pro`、`ProMax`;
其余已知套餐使用官方名称,未知 OpenAI 套餐保留原值。
其余已知 OpenAI 套餐使用 Codex `/status` 的名称,例如 `self_serve_business_prolite` 显示为 `Business Premium`,
`self_serve_business_usage_based` 显示为 `Business`。未知 OpenAI 套餐保留原值。
展示名称保留空格和括号,未提供专属名称规则的 Provider 使用通用大驼峰格式。
OpenAI 主动额度刷新和正常响应携带的明确套餐会同步到账号,支持升级与降级;
空值或 `unknown` 不覆盖已有套餐,同族泛化值(如 `team`)保留已知的具体套餐子类型。
+7 -7
View File
@@ -424,7 +424,8 @@ sequenceDiagram
模型请求默认不限制总执行时长;插件显式设置的总时限从请求开始计时,Provider 的传输空闲超时独立生效。
Client Key 并发占用、账号调度槽位与请求恢复记录使用可续期租约,不把租约 TTL 当作总执行预算。
会话结束或 Drop 后停止续期;Redis 并发租约丢失或无法在有效期内续期时取消请求,避免失去并发约束后继续执行
账号调度槽位随上游流释放。流返回错误、读到 EOF 或网关终止读取时即触发归还,费用结算与请求记录可继续完成。
Redis 并发租约丢失或无法在有效期内续期时取消请求,避免失去并发约束后继续执行
Client Key 鉴权完成后,API adapter 从有界请求头识别客户端,Core 使用请求冻结的 `RuntimeSnapshot`
检查最低版本,在进入 Provider 前完成门禁。请求头优先级、远程客户端识别与错误合同见[鉴权约定](api.md#1-鉴权与公共约定)
@@ -546,9 +547,8 @@ OpenAI Provider 按 Client Key、所选 OAuth 账号和父响应 ID 关联 WS
连接池按快照身份隔离审查连接;复用父连接不会重新计算 Cookie 有效期,Cookie 到期不强制关闭已建立的审查连接
OpenAI OAuth 的连接、续接状态、Guardian 路由 Cookie 和头像缓存按本地账号、上游用户与工作区隔离,同号令牌续期不改变归属。
OpenAI Provider 统一处理 Responses 的账号归属与 turn state 隔离,HTTP 与 WS 消费同一出站请求。
全量请求缺少本地归属记录时保留客户端回传的路由 token,明确换号或可信续接状态不属于同一轮时清除;
turn state 不参与选号,也不授权其他账号状态或 response ID 的复用
Responses 的轮次路由 token 由客户端回传,OpenAI Provider 只在明确换号时清除。
选号和 response ID 的归属校验独立于该 token
### 账号协议与字段适配
@@ -981,7 +981,8 @@ PostgreSQL schema 由迁移目录按编号管理;冻结、升级与校验规
### 账号模型目录
OpenAI 在 PostgreSQL 保存账号最近一次成功的模型目录、凭据版本、观测时间及 ETag。启动时批量恢复,按不同正文解析一次,保留每个账号的独立归属。没有历史目录也能发布路由快照;能力读取与推理不等待上游查询。
后台刷新缺少目录、距上次成功观测已满 30 分钟或收到新 ETag 的账号。刷新期间及失败后继续使用上次成功的目录;凭据或套餐变化后不沿用旧目录。
账号缺少目录或收到新 ETag 时,后台重新查询该账号。正常响应的 ETag 与该账号当前凭据和套餐的目录一致时,在内存中续期。距上次成功拉取或确认满 1 小时后,由后台复查。重启后从持久化的目录观测时间起算。
刷新期间及失败后继续使用上次成功的目录。凭据或套餐变化后重新发现模型。
刷新并发与节奏由 [Provider 目录实现](../backend/crates/providers/openai/src/credential/catalog/mod.rs)统一维护
OpenAI 从账号目录生成原生列表;先按冻结政策选择来源,再读取本地账号状态核对凭据版本。同一份正文可以复用,但不会把一个账号的模型授予同套餐的其他账号。客户端版本和 Key 身份不触发额外发现
@@ -1229,8 +1230,7 @@ observation、调用 metadata;最终失败的关联头不与 opening 身份混
这一冷流约束同样覆盖 attempt 中间件的响应读取,Core 校验元数据并登记 attempt 后才允许开始读取。
不能因首写失败或缺少 metadata 而伪造零尝试、账号、传输或 `not_sent`
Provider 流返回的错误、随附事件与重试决策由 Core 会话持有;取消单次等待只暂停该错误的处理,
不能因等待取消而重复读取上游或重建 attempt
Provider 流返回错误时,Core 会话保留原始错误、随附事件与重试决策,取消单次等待后可继续处理同一次失败
终态观测写入由会话持有;事件等待被取消后,后续 poll 或 detached finalizer 继续同一个 future,
保留原结果及完成时间,不重复创建请求。观测写入失败仍为 best-effort,不阻断费用结算与准入释放。
@@ -14,6 +14,7 @@ const props = withDefaults(
planTypeDisplay: string
count?: number
size?: 'xs' | 'sm' | 'md'
wrap?: boolean
}>(),
{
planType: null,
@@ -43,13 +44,11 @@ const displayText = computed(() => props.authenticationKind === 'api_key'
? 'API'
: props.planTypeDisplay)
const sizeClass = computed(() => {
if (props.size === 'xs')
return 'h-4.5 rounded-full px-1.5 text-[10px] font-bold'
return props.size === 'sm'
? 'h-5 rounded-full px-1.75 text-z-xs font-bold'
: 'h-5.5 rounded-full px-2 text-z-xs font-heavy'
})
const sizes = {
xs: { text: 'text-[10px] font-bold', singleLine: 'h-4.5 px-1.5' },
sm: { text: 'text-z-xs font-bold', singleLine: 'h-5 px-1.75' },
md: { text: 'text-z-xs font-heavy', singleLine: 'h-5.5 px-2' },
}
const paletteClass = computed(() => {
const key = rawPlanType.value.toLowerCase()
@@ -65,11 +64,16 @@ const paletteClass = computed(() => {
<AccountUpstreamBadge v-if="upstreamPeer || upstream?.discovered" :size="size" />
<span
v-else
class="inline-flex min-w-0 max-w-full items-center justify-center gap-1 whitespace-nowrap leading-none shadow-z-tertiary"
:class="[sizeClass, paletteClass]"
class="inline-flex min-w-0 max-w-full items-center justify-center gap-1 shadow-z-tertiary"
:class="[
sizes[size].text, paletteClass,
wrap
? 'min-h-5.5 rounded-lg px-1 py-0.75 text-center leading-3.5'
: [sizes[size].singleLine, 'rounded-full whitespace-nowrap leading-none'],
]"
:title="displayText || undefined"
>
<span class="truncate">{{ displayText }}</span>
<span :class="wrap ? 'line-clamp-3 text-balance wrap-anywhere whitespace-normal' : 'truncate'">{{ displayText }}</span>
<span v-if="count !== undefined" class="shrink-0 tabular-nums">{{ count }}</span>
</span>
</template>
@@ -79,14 +79,19 @@ const { t } = useI18n({ useScope: 'global' })
</template>
<template #accountPlanType="{ row }">
<AccountPlanBadge
<div
v-if="row.accountUpstreamPeer || row.authenticationKind === 'api_key' || row.accountPlanType"
:authentication-kind="row.authenticationKind ?? undefined"
:upstream-peer="row.accountUpstreamPeer"
:plan-type="row.accountPlanType"
:plan-type-display="row.accountPlanTypeDisplay || row.accountPlanType || ''"
size="sm"
/>
class="-mx-2.5 flex min-w-0 justify-center"
>
<AccountPlanBadge
wrap
:authentication-kind="row.authenticationKind ?? undefined"
:upstream-peer="row.accountUpstreamPeer"
:plan-type="row.accountPlanType"
:plan-type-display="row.accountPlanTypeDisplay || row.accountPlanType || ''"
size="sm"
/>
</div>
<span v-else class="text-z-text-quaternary">—</span>
</template>
+2 -2
View File
@@ -327,8 +327,8 @@ const {
</template>
<template #planType="{ row }">
<div class="flex min-w-0 justify-center">
<AccountPlanBadge :upstream="row.upstream" :authentication-kind="row.authenticationKind" :plan-type="row.planType" :plan-type-display="row.planTypeDisplay" />
<div class="-mx-2.5 flex min-w-0 justify-center">
<AccountPlanBadge wrap :upstream="row.upstream" :authentication-kind="row.authenticationKind" :plan-type="row.planType" :plan-type-display="row.planTypeDisplay" />
</div>
</template>
+6 -11
View File
@@ -1,16 +1,11 @@
# v3.52.0
## 新增功能
- 请求记录可按历史账号名称或邮箱筛选
- 内置 GPT-6.2 Astra 和 Sol 价目,Ultrafast 按常规价估算
# v3.52.1
## 优化改进
- 请求记录用双闪电标识 Ultrafast,用单闪电标识 Fast
- 请求错误来源图标改为无底色显示
- 账号列表和请求记录按 Codex 名称展示 Business、Enterprise 和科研套餐,长名称在原列宽内换行,Pro 三档沿用原有短名
- OpenAI 模型目录的 ETag 与已保存目录一致时,后台复查推迟一小时,减少重复请求
## 升级须知
## 问题修复
- 调用 `GET /api/admin/usage/records` 的客户端需将查询参数 `accountName` 改为 `accountSearch`,旧参数会返回 HTTP 400
- 自行部署时请确认 PostgreSQL 版本为 16 或更高,默认 Compose 使用 PostgreSQL 18
- 修复上游响应结束、报错或请求取消后,账号并发槽位仍被占用到记账完成的问题
- Codex WebSocket 按当前请求转发轮次状态和元数据,避免后续轮次沿用握手时的值,切换账号时清除原账号的轮次状态
+5 -5
View File
@@ -1,7 +1,7 @@
version: 3.52.0
version: 3.52.1
published:
'3':
stable: 3.51.0
rc: 3.51.0
beta: 3.51.0
alpha: 3.51.0
stable: 3.52.0
rc: 3.52.0
beta: 3.52.0
alpha: 3.52.0