Merge remote-tracking branch 'zhefox/main' into zhefox-main

# Conflicts:
#	crates/aether-admin/src/provider/quota.rs
#	crates/aether-ai/formats/src/formats/openai/chat/stream.rs
#	crates/aether-ai/formats/src/formats/openai/responses/mod.rs
#	crates/aether-provider/pool/src/provider.rs
#	crates/aether-provider/pool/src/quota.rs

apps/aether-gateway/src/ai_serving/codex_context.rs

@@ -0,0 +1,249 @@
+use std::sync::{Arc, OnceLock};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use aether_provider_transport::CodexFingerprintConvergenceContext;
+use http::{request::Parts, HeaderMap};
+use serde_json::Value;
+use uuid::Uuid;
+
+use crate::client_session_affinity::codex_request_signals_from_request;
+
+#[derive(Debug, Clone)]
+pub(crate) struct CodexFingerprintContextSlot(Arc<OnceLock<CodexFingerprintConvergenceContext>>);
+
+impl Default for CodexFingerprintContextSlot {
+    fn default() -> Self {
+        Self(Arc::new(OnceLock::new()))
+    }
+}
+
+impl CodexFingerprintContextSlot {
+    fn resolve(
+        &self,
+        headers: &HeaderMap,
+        body_json: &Value,
+    ) -> CodexFingerprintConvergenceContext {
+        self.0
+            .get_or_init(|| {
+                build_codex_fingerprint_context(headers, body_json, Uuid::now_v7().to_string())
+            })
+            .clone()
+    }
+}
+
+pub(crate) fn resolve_codex_fingerprint_context(
+    parts: &Parts,
+    body_json: &Value,
+) -> CodexFingerprintConvergenceContext {
+    if let Some(context) = parts
+        .extensions
+        .get::<CodexFingerprintConvergenceContext>()
+        .cloned()
+    {
+        return context;
+    }
+    if let Some(slot) = parts.extensions.get::<CodexFingerprintContextSlot>() {
+        return slot.resolve(&parts.headers, body_json);
+    }
+    build_codex_fingerprint_context(&parts.headers, body_json, Uuid::now_v7().to_string())
+}
+
+pub(crate) fn install_codex_fingerprint_context_slot(parts: &mut Parts) {
+    if parts
+        .extensions
+        .get::<CodexFingerprintConvergenceContext>()
+        .is_none()
+        && parts
+            .extensions
+            .get::<CodexFingerprintContextSlot>()
+            .is_none()
+    {
+        parts
+            .extensions
+            .insert(CodexFingerprintContextSlot::default());
+    }
+}
+
+pub(crate) fn ensure_codex_fingerprint_context(
+    parts: &mut Parts,
+    body_json: &Value,
+) -> CodexFingerprintConvergenceContext {
+    let context = resolve_codex_fingerprint_context(parts, body_json);
+    if parts
+        .extensions
+        .get::<CodexFingerprintConvergenceContext>()
+        .is_none()
+    {
+        parts.extensions.remove::<CodexFingerprintContextSlot>();
+        parts.extensions.insert(context.clone());
+    }
+    context
+}
+
+pub(crate) fn attach_codex_logical_turn_context(
+    parts: &mut Parts,
+    body_json: &Value,
+    logical_turn_id: &str,
+) -> CodexFingerprintConvergenceContext {
+    let context =
+        build_codex_fingerprint_context(&parts.headers, body_json, logical_turn_id.to_string());
+    parts.extensions.remove::<CodexFingerprintContextSlot>();
+    parts.extensions.insert(context.clone());
+    context
+}
+
+pub(crate) fn restore_codex_logical_turn_context(
+    parts: &mut Parts,
+    context: &CodexFingerprintConvergenceContext,
+) {
+    parts.extensions.remove::<CodexFingerprintContextSlot>();
+    parts.extensions.insert(context.clone());
+}
+
+fn build_codex_fingerprint_context(
+    headers: &HeaderMap,
+    body_json: &Value,
+    logical_turn_id: String,
+) -> CodexFingerprintConvergenceContext {
+    let signals = codex_request_signals_from_request(headers, Some(body_json));
+    let mut context =
+        CodexFingerprintConvergenceContext::new(logical_turn_id, current_unix_millis());
+
+    if let Some(turn_id) = signals.turn_id {
+        context = context.with_original_turn_id(turn_id);
+    }
+    if let Some(session_id) = signals.thread_id.or(signals.session_id) {
+        context = context.with_original_client_session_id(session_id);
+    }
+    if let Some(prompt_cache_key) = signals.prompt_cache_key {
+        context = context.with_original_prompt_cache_key(prompt_cache_key);
+    }
+
+    context
+}
+
+fn current_unix_millis() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_millis()
+        .try_into()
+        .unwrap_or(u64::MAX)
+}
+
+#[cfg(test)]
+mod tests {
+    use http::HeaderValue;
+    use serde_json::json;
+
+    use super::*;
+
+    #[test]
+    fn request_signals_are_captured_once_for_the_logical_turn() {
+        let request = http::Request::builder()
+            .header("thread-id", "header-thread")
+            .body(())
+            .expect("request should build");
+        let (mut parts, _) = request.into_parts();
+        let body = json!({
+            "prompt_cache_key": "client-cache",
+            "client_metadata": {
+                "turn_id": "client-turn",
+                "thread_id": "body-thread"
+            }
+        });
+
+        let context = attach_codex_logical_turn_context(&mut parts, &body, "logical-turn");
+
+        assert_eq!(context.logical_turn_id(), "logical-turn");
+        assert_eq!(context.original_turn_id(), Some("client-turn"));
+        assert_eq!(context.original_client_session_id(), Some("header-thread"));
+        assert_eq!(context.original_prompt_cache_key(), Some("client-cache"));
+        assert_eq!(
+            parts.extensions.get::<CodexFingerprintConvergenceContext>(),
+            Some(&context)
+        );
+    }
+
+    #[test]
+    fn restored_context_wins_over_retry_request_signals() {
+        let original = CodexFingerprintConvergenceContext::new("logical-turn", 1234)
+            .with_original_turn_id("original-turn")
+            .with_original_client_session_id("original-thread")
+            .with_original_prompt_cache_key("original-cache");
+        let request = http::Request::builder()
+            .body(())
+            .expect("request should build");
+        let (mut parts, _) = request.into_parts();
+        parts
+            .headers
+            .insert("thread-id", HeaderValue::from_static("retry-thread"));
+        restore_codex_logical_turn_context(&mut parts, &original);
+
+        let resolved = resolve_codex_fingerprint_context(
+            &parts,
+            &json!({
+                "prompt_cache_key": "retry-cache",
+                "client_metadata": {"turn_id": "retry-turn"}
+            }),
+        );
+
+        assert_eq!(resolved, original);
+        assert_eq!(resolved.turn_started_at_unix_ms(), 1234);
+    }
+
+    #[test]
+    fn generated_context_is_persisted_for_http_replanning() {
+        let request = http::Request::builder()
+            .header("session-id", "client-session")
+            .body(())
+            .expect("request should build");
+        let (mut parts, _) = request.into_parts();
+        let body = json!({
+            "prompt_cache_key": "client-cache",
+            "client_metadata": {"turn_id": "client-turn"}
+        });
+
+        let first = ensure_codex_fingerprint_context(&mut parts, &body);
+        let second = resolve_codex_fingerprint_context(
+            &parts,
+            &json!({
+                "prompt_cache_key": "retry-cache",
+                "client_metadata": {"turn_id": "retry-turn"}
+            }),
+        );
+
+        assert_eq!(second, first);
+        assert_eq!(second.original_turn_id(), Some("client-turn"));
+        assert_eq!(second.original_prompt_cache_key(), Some("client-cache"));
+    }
+
+    #[test]
+    fn installed_slot_reuses_context_across_cloned_parts() {
+        let request = http::Request::builder()
+            .body(())
+            .expect("request should build");
+        let (mut parts, _) = request.into_parts();
+        install_codex_fingerprint_context_slot(&mut parts);
+        let cloned_parts = parts.clone();
+
+        let first = resolve_codex_fingerprint_context(
+            &parts,
+            &json!({
+                "prompt_cache_key": "first-cache",
+                "client_metadata": {"turn_id": "first-turn"}
+            }),
+        );
+        let second = resolve_codex_fingerprint_context(
+            &cloned_parts,
+            &json!({
+                "prompt_cache_key": "second-cache",
+                "client_metadata": {"turn_id": "second-turn"}
+            }),
+        );
+
+        assert_eq!(second, first);
+        assert_eq!(second.original_turn_id(), Some("first-turn"));
+        assert_eq!(second.original_prompt_cache_key(), Some("first-cache"));
+    }
+}

apps/aether-gateway/src/ai_serving/mod.rs

@@ -1,5 +1,6 @@
 mod adaptation;
 pub(crate) mod api;
+pub(crate) mod codex_context;
 mod finalize;
 mod planner;
 mod pure;

apps/aether-gateway/src/ai_serving/planner/candidate_source.rs

@@ -86,6 +86,52 @@ impl GatewayLocalCandidatePreselectionPort<'_> {
     }
 }
 
+/// A Responses compaction request carries the OpenAI-only `compaction_trigger`
+/// control item.  It must stay on an OpenAI Responses endpoint: treating it as
+/// an ordinary cross-format request would make Gemini/Claude candidates look
+/// eligible and defer the inevitable lossy-conversion failure until payload
+/// construction.
+fn request_candidate_api_formats_for_operation(
+    client_api_format: &str,
+    require_streaming: bool,
+    request_operation: Option<&str>,
+) -> Vec<String> {
+    let candidate_api_formats =
+        crate::ai_serving::request_candidate_api_formats(client_api_format, require_streaming)
+            .into_iter()
+            .map(str::to_string)
+            .collect::<Vec<_>>();
+
+    restrict_candidate_api_formats_for_operation(
+        client_api_format,
+        request_operation,
+        candidate_api_formats,
+    )
+}
+
+fn restrict_candidate_api_formats_for_operation(
+    client_api_format: &str,
+    request_operation: Option<&str>,
+    candidate_api_formats: Vec<String>,
+) -> Vec<String> {
+    let is_responses_compaction = request_operation.is_some_and(|operation| {
+        operation.eq_ignore_ascii_case(crate::ai_serving::OPENAI_RESPONSES_OPERATION_COMPACT)
+    });
+    let is_standard_responses_client =
+        crate::ai_serving::normalize_api_format_alias(client_api_format) == "openai:responses";
+    if !(is_responses_compaction && is_standard_responses_client) {
+        return candidate_api_formats;
+    }
+
+    candidate_api_formats
+        .into_iter()
+        .filter(|candidate_api_format| {
+            crate::ai_serving::normalize_api_format_alias(candidate_api_format)
+                == "openai:responses"
+        })
+        .collect()
+}
+
 #[async_trait]
 impl AiCandidatePreselectionPort for GatewayLocalCandidatePreselectionPort<'_> {
     type Candidate = SchedulerMinimalCandidateSelectionCandidate;
@@ -219,11 +265,11 @@ pub(crate) async fn preselect_local_execution_candidates_with_serving(
     >,
     GatewayError,
 > {
-    let candidate_api_formats =
-        crate::ai_serving::request_candidate_api_formats(client_api_format, require_streaming)
-            .into_iter()
-            .map(str::to_string)
-            .collect::<Vec<_>>();
+    let candidate_api_formats = request_candidate_api_formats_for_operation(
+        client_api_format,
+        require_streaming,
+        request_operation,
+    );
     preselect_local_execution_candidates_for_api_formats_with_serving(
         state,
         model_directive_policy,
@@ -264,6 +310,11 @@ pub(crate) async fn preselect_local_execution_candidates_for_api_formats_with_se
     >,
     GatewayError,
 > {
+    let candidate_api_formats = restrict_candidate_api_formats_for_operation(
+        client_api_format,
+        request_operation,
+        candidate_api_formats,
+    );
     let model_directive_routing_models = resolve_model_directive_routing_models(
         model_directive_policy,
         &candidate_api_formats,
@@ -362,11 +413,11 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
         allow_priority_page_cache: bool,
         trace_id: Option<&str>,
     ) -> Self {
-        let candidate_api_formats =
-            crate::ai_serving::request_candidate_api_formats(client_api_format, require_streaming)
-                .into_iter()
-                .map(str::to_string)
-                .collect::<Vec<_>>();
+        let candidate_api_formats = request_candidate_api_formats_for_operation(
+            client_api_format,
+            require_streaming,
+            request_operation,
+        );
         let model_directive_routing_models = resolve_model_directive_routing_models(
             model_directive_policy,
             &candidate_api_formats,
@@ -1437,6 +1488,31 @@ mod tests {
     use std::sync::atomic::{AtomicUsize, Ordering};
     use std::sync::{Arc, Mutex};
 
+    #[test]
+    fn compaction_operation_excludes_non_responses_provider_formats() {
+        assert_eq!(
+            request_candidate_api_formats_for_operation("openai:responses", true, Some("compact"),),
+            vec!["openai:responses"]
+        );
+        assert_eq!(
+            request_candidate_api_formats_for_operation("openai:responses", true, None),
+            vec![
+                "openai:responses",
+                "openai:chat",
+                "claude:messages",
+                "gemini:generate_content"
+            ]
+        );
+        assert_eq!(
+            request_candidate_api_formats_for_operation(
+                "openai:responses:compact",
+                false,
+                Some("compact"),
+            ),
+            vec!["openai:responses:compact"]
+        );
+    }
+
     #[derive(Default)]
     struct EmptyFallbackCountingRepository {
         fallback_reads: AtomicUsize,

apps/aether-gateway/src/ai_serving/planner/decision_input.rs

@@ -13,6 +13,7 @@ use http::{HeaderMap, HeaderName, HeaderValue};
 use serde_json::{json, Value};
 
 use crate::ai_serving::planner::common::extract_standard_requested_model;
+use crate::ai_serving::transport::CodexFingerprintConvergenceContext;
 use crate::ai_serving::{
     ClientSurface, ExecutionRuntimeAuthContext, GatewayAuthApiKeySnapshot,
     GatewayCredentialCarrier, GatewayProviderTransportSnapshot, PlannerAppState,
@@ -55,7 +56,7 @@ pub(crate) struct LocalRequestedModelDecisionInput {
     pub(crate) client_surface: Option<ClientSurface>,
     pub(crate) gateway_credential_carrier: Option<GatewayCredentialCarrier>,
     pub(crate) client_session_affinity: Option<ClientSessionAffinity>,
-    pub(crate) original_client_session_id: Option<String>,
+    pub(crate) codex_fingerprint_context: Option<CodexFingerprintConvergenceContext>,
     pub(crate) routing_policy: Option<ResolvedRoutingPolicy>,
     pub(crate) routing_trace_seed: Option<RoutingDecisionTrace>,
     pub(crate) routing_context: Option<LocalRoutingRequestContext>,
@@ -167,7 +168,7 @@ pub(crate) fn apply_provider_request_routing_policy_to_decision_with_websocket_m
                 provider_api_format.as_str(),
             );
         }
-        apply_codex_oauth_fingerprint_convergence_to_decision(
+        apply_codex_fingerprint_convergence_to_decision(
             input,
             decision,
             transport,
@@ -230,7 +231,7 @@ pub(crate) fn apply_provider_request_routing_policy_to_decision_with_websocket_m
                 provider_api_format.as_str(),
             );
         }
-        apply_codex_oauth_fingerprint_convergence_to_decision(
+        apply_codex_fingerprint_convergence_to_decision(
             input,
             decision,
             transport,
@@ -291,6 +292,7 @@ pub(crate) fn apply_provider_request_routing_policy_to_decision_with_websocket_m
                     crate::ai_serving::openai_responses_reasoning_replay_policy(
                         transport.provider.provider_type.as_str(),
                         transport.endpoint.base_url.as_str(),
+                        provider_model.as_str(),
                     )
                 })
                 .unwrap_or_default();
@@ -355,7 +357,7 @@ pub(crate) fn apply_provider_request_routing_policy_to_decision_with_websocket_m
     if original_provider_request_body.is_some() {
         decision.provider_request_body = Some(provider_request_body);
     }
-    apply_codex_oauth_fingerprint_convergence_to_decision(
+    apply_codex_fingerprint_convergence_to_decision(
         input,
         decision,
         transport,
@@ -365,7 +367,7 @@ pub(crate) fn apply_provider_request_routing_policy_to_decision_with_websocket_m
     Ok(())
 }
 
-fn apply_codex_oauth_fingerprint_convergence_to_decision(
+fn apply_codex_fingerprint_convergence_to_decision(
     input: &LocalRequestedModelDecisionInput,
     decision: &mut AiExecutionDecision,
     transport: Option<&GatewayProviderTransportSnapshot>,
@@ -376,13 +378,24 @@ fn apply_codex_oauth_fingerprint_convergence_to_decision(
     else {
         return;
     };
-    crate::ai_serving::transport::apply_codex_oauth_fingerprint_convergence(
+    let Some(context) = input.codex_fingerprint_context.as_ref() else {
+        return;
+    };
+    let applied = crate::ai_serving::transport::apply_codex_fingerprint_convergence_with_context(
         transport,
         provider_api_format,
-        input.original_client_session_id.as_deref(),
+        context,
         &mut decision.provider_request_headers,
         provider_request_body,
     );
+    if applied {
+        decision.prompt_cache_key = provider_request_body
+            .get("prompt_cache_key")
+            .and_then(Value::as_str)
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+            .map(ToOwned::to_owned);
+    }
 }
 
 struct GatewayAuthenticatedDecisionInputPort<'a> {
@@ -471,7 +484,7 @@ pub(crate) fn build_local_requested_model_decision_input(
         client_surface: None,
         gateway_credential_carrier: None,
         client_session_affinity: None,
-        original_client_session_id: None,
+        codex_fingerprint_context: None,
         routing_policy: None,
         routing_trace_seed: None,
         routing_context: None,
@@ -486,7 +499,8 @@ pub(crate) async fn attach_routing_policy_to_local_requested_model_input(
     body_json: &Value,
     client_api_format: &str,
 ) -> Result<(), GatewayError> {
-    input.original_client_session_id = original_client_session_id_from_headers(&parts.headers);
+    input.codex_fingerprint_context =
+        Some(crate::ai_serving::codex_context::resolve_codex_fingerprint_context(parts, body_json));
     let explicit_group = routing_header_value_str(&parts.headers, ROUTING_GROUP_HEADER);
     let selected_group = match state.routing_group_read_repository() {
         Some(repository) => {
@@ -737,12 +751,6 @@ pub(crate) async fn attach_routing_policy_to_local_requested_model_input(
     Ok(())
 }
 
-fn original_client_session_id_from_headers(headers: &HeaderMap) -> Option<String> {
-    routing_header_value_str(headers, "session-id")
-        .or_else(|| routing_header_value_str(headers, "session_id"))
-        .or_else(|| routing_header_value_str(headers, "x-session-id"))
-}
-
 fn try_attach_static_default_routing_policy_to_input(
     input: &mut LocalRequestedModelDecisionInput,
     parts: &http::request::Parts,
@@ -1106,38 +1114,6 @@ mod tests {
         GatewayProviderTransportProvider,
     };
 
-    #[test]
-    fn original_client_session_id_accepts_live_header_as_fallback() {
-        let headers = HeaderMap::from_iter([(
-            HeaderName::from_static("x-session-id"),
-            HeaderValue::from_static("live-thread-1"),
-        )]);
-
-        assert_eq!(
-            original_client_session_id_from_headers(&headers).as_deref(),
-            Some("live-thread-1")
-        );
-    }
-
-    #[test]
-    fn original_client_session_id_prefers_responses_headers_over_live_fallback() {
-        let headers = HeaderMap::from_iter([
-            (
-                HeaderName::from_static("session-id"),
-                HeaderValue::from_static("responses-session"),
-            ),
-            (
-                HeaderName::from_static("x-session-id"),
-                HeaderValue::from_static("live-thread"),
-            ),
-        ]);
-
-        assert_eq!(
-            original_client_session_id_from_headers(&headers).as_deref(),
-            Some("responses-session")
-        );
-    }
-
     #[test]
     fn explicit_routing_selection_cache_key_is_principal_specific() {
         let first = routing_group_selection_cache_key(
@@ -1350,7 +1326,7 @@ mod tests {
             client_surface: None,
             gateway_credential_carrier: None,
             client_session_affinity: None,
-            original_client_session_id: None,
+            codex_fingerprint_context: None,
             routing_policy: None,
             routing_trace_seed: None,
             model_directive_policy: Default::default(),
@@ -1599,7 +1575,7 @@ mod tests {
             client_surface: None,
             gateway_credential_carrier: None,
             client_session_affinity: None,
-            original_client_session_id: None,
+            codex_fingerprint_context: None,
             routing_policy: None,
             routing_trace_seed: None,
             model_directive_policy: Default::default(),
@@ -1669,7 +1645,7 @@ mod tests {
             client_surface: None,
             gateway_credential_carrier: None,
             client_session_affinity: None,
-            original_client_session_id: None,
+            codex_fingerprint_context: None,
             routing_policy: None,
             routing_trace_seed: None,
             routing_context: None,
@@ -1754,7 +1730,13 @@ mod tests {
         });
         let mut with_mutation = sample_decision_input();
         for input in [&mut no_context, &mut empty_mutation, &mut with_mutation] {
-            input.original_client_session_id = Some("client-session-1".to_string());
+            input.codex_fingerprint_context = Some(
+                CodexFingerprintConvergenceContext::new(
+                    uuid::Uuid::new_v4().to_string(),
+                    1_756_668_000_000,
+                )
+                .with_original_client_session_id("client-session-1".to_string()),
+            );
         }
 
         let mut stable_identity = None;
@@ -1801,6 +1783,10 @@ mod tests {
                 .provider_request_body
                 .as_ref()
                 .expect("request body");
+            assert_eq!(
+                decision.prompt_cache_key.as_deref(),
+                body.get("prompt_cache_key").and_then(Value::as_str)
+            );
             assert_eq!(
                 body["prompt_cache_key"],
                 "172c39e6-c0a0-5a70-8b63-e0f8e0d185a3"
@@ -2005,6 +1991,7 @@ mod tests {
 
         let body = decision.provider_request_body.as_ref().expect("body");
         assert!(body.get("prompt_cache_key").is_none());
+        assert!(decision.prompt_cache_key.is_none());
         assert!(body.get("client_metadata").is_none());
         assert!(!decision.provider_request_headers.contains_key("session-id"));
         assert!(!decision.provider_request_headers.contains_key("thread-id"));

apps/aether-gateway/src/ai_serving/planner/passthrough/provider/family/request.rs

@@ -183,6 +183,7 @@ pub(crate) async fn resolve_local_same_format_provider_candidate_payload_parts(
     let reasoning_replay_policy = openai_responses_reasoning_replay_policy(
         prepared.transport.provider.provider_type.as_str(),
         prepared.transport.endpoint.base_url.as_str(),
+        prepared.mapped_model.as_str(),
     );
     let redaction = resolve_provider_chat_pii_redaction(
         state,

apps/aether-gateway/src/ai_serving/planner/standard/deepseek.rs

@@ -15,11 +15,25 @@ pub(crate) fn is_deepseek_provider(provider_type: &str, base_url: &str) -> bool
     host == "deepseek.com" || host.ends_with(".deepseek.com")
 }
 
+fn is_deepseek_model(provider_model: &str) -> bool {
+    let provider_model = provider_model.trim().to_ascii_lowercase();
+    let leaf = provider_model
+        .rsplit(['/', ':'])
+        .next()
+        .unwrap_or(provider_model.as_str());
+    leaf == "deepseek" || leaf.starts_with("deepseek-") || leaf.starts_with("deepseek_")
+}
+
+fn is_deepseek_upstream(provider_type: &str, base_url: &str, provider_model: &str) -> bool {
+    is_deepseek_provider(provider_type, base_url) || is_deepseek_model(provider_model)
+}
+
 pub(crate) fn openai_responses_reasoning_replay_policy(
     provider_type: &str,
     base_url: &str,
+    provider_model: &str,
 ) -> crate::ai_serving::OpenAiResponsesReasoningReplayPolicy {
-    if is_deepseek_provider(provider_type, base_url) {
+    if is_deepseek_upstream(provider_type, base_url, provider_model) {
         crate::ai_serving::OpenAiResponsesReasoningReplayPolicy::DeepSeekOpaque
     } else {
         crate::ai_serving::OpenAiResponsesReasoningReplayPolicy::OpenAiItemIds
@@ -33,7 +47,11 @@ pub(crate) fn apply_deepseek_tool_call_thinking_compat(
     provider_api_format: &str,
     original_request_body: Option<&Value>,
 ) {
-    if !is_deepseek_provider(provider_type, base_url) {
+    let provider_model = provider_request_body
+        .get("model")
+        .and_then(Value::as_str)
+        .unwrap_or_default();
+    if !is_deepseek_upstream(provider_type, base_url, provider_model) {
         return;
     }
 
@@ -302,11 +320,35 @@ mod tests {
         ));
         assert!(!is_deepseek_provider("custom", "ftp://api.deepseek.com/v1"));
         assert_eq!(
-            openai_responses_reasoning_replay_policy("custom", "https://api.deepseek.com/v1"),
+            openai_responses_reasoning_replay_policy(
+                "custom",
+                "https://api.deepseek.com/v1",
+                "deepseek-v4-flash",
+            ),
             crate::ai_serving::OpenAiResponsesReasoningReplayPolicy::DeepSeekOpaque
         );
         assert_eq!(
-            openai_responses_reasoning_replay_policy("openai", "https://api.openai.com/v1"),
+            openai_responses_reasoning_replay_policy(
+                "openai",
+                "https://api.openai.com/v1",
+                "gpt-5.6-sol",
+            ),
+            crate::ai_serving::OpenAiResponsesReasoningReplayPolicy::OpenAiItemIds
+        );
+        assert_eq!(
+            openai_responses_reasoning_replay_policy(
+                "custom",
+                "https://api.b.ai/v1",
+                "deepseek-v4-flash",
+            ),
+            crate::ai_serving::OpenAiResponsesReasoningReplayPolicy::DeepSeekOpaque
+        );
+        assert_eq!(
+            openai_responses_reasoning_replay_policy(
+                "custom",
+                "https://api.b.ai/v1",
+                "not-deepseek-compatible",
+            ),
             crate::ai_serving::OpenAiResponsesReasoningReplayPolicy::OpenAiItemIds
         );
     }
@@ -330,8 +372,11 @@ mod tests {
             "input": reasoning_items.clone(),
             "future_request_field": {"preserve": true}
         });
-        let replay_policy =
-            openai_responses_reasoning_replay_policy("custom", "https://api.deepseek.com/v1");
+        let replay_policy = openai_responses_reasoning_replay_policy(
+            "custom",
+            "https://api.deepseek.com/v1",
+            "deepseek-v4-flash",
+        );
         let mut provider_body = crate::ai_serving::build_standard_request_body_with_model_directives_and_request_headers_and_reasoning_replay_policy(
             &request,
             "openai:responses",
@@ -373,7 +418,11 @@ mod tests {
             crate::ai_serving::strip_incompatible_openai_responses_reasoning_items_with_policy(
                 &mut deepseek,
                 "openai:responses",
-                openai_responses_reasoning_replay_policy("custom", "https://api.deepseek.com/v1"),
+                openai_responses_reasoning_replay_policy(
+                    "custom",
+                    "https://api.deepseek.com/v1",
+                    "deepseek-v4-flash",
+                ),
             ),
             0
         );
@@ -383,7 +432,11 @@ mod tests {
             crate::ai_serving::strip_incompatible_openai_responses_reasoning_items_with_policy(
                 &mut openai,
                 "openai:responses",
-                openai_responses_reasoning_replay_policy("openai", "https://api.openai.com/v1"),
+                openai_responses_reasoning_replay_policy(
+                    "openai",
+                    "https://api.openai.com/v1",
+                    "gpt-5.6-sol",
+                ),
             ),
             66
         );
@@ -417,6 +470,52 @@ mod tests {
         assert_eq!(body["messages"][1]["reasoning_content"], "");
     }
 
+    #[test]
+    fn custom_relay_deepseek_model_adds_chat_thinking_compat() {
+        let mut body = json!({
+            "model": "deepseek-v4-flash",
+            "messages": [
+                {"role": "user", "content": "inspect the repository"},
+                {"role": "assistant", "content": null, "tool_calls": [{
+                    "id": "call_1",
+                    "type": "function",
+                    "function": {"name": "inspect", "arguments": "{}"}
+                }]},
+                {"role": "tool", "tool_call_id": "call_1", "content": "done"}
+            ]
+        });
+
+        apply_deepseek_tool_call_thinking_compat(
+            &mut body,
+            "custom",
+            "https://api.b.ai/v1",
+            "openai:chat",
+            None,
+        );
+
+        assert_eq!(body["thinking"]["type"], "enabled");
+        assert_eq!(body["messages"][1]["reasoning_content"], "");
+    }
+
+    #[test]
+    fn custom_relay_non_deepseek_model_is_not_rewritten() {
+        let original = json!({
+            "model": "not-deepseek-compatible",
+            "messages": [{"role": "assistant", "content": "done"}]
+        });
+        let mut body = original.clone();
+
+        apply_deepseek_tool_call_thinking_compat(
+            &mut body,
+            "custom",
+            "https://api.b.ai/v1",
+            "openai:chat",
+            None,
+        );
+
+        assert_eq!(body, original);
+    }
+
     #[test]
     fn openai_chat_deepseek_honors_disabled_thinking() {
         let original = json!({"reasoning_effort": "none"});

apps/aether-gateway/src/ai_serving/planner/standard/family/payload.rs

@@ -377,7 +377,7 @@ mod tests {
             client_surface: None,
             gateway_credential_carrier: None,
             client_session_affinity: None,
-            original_client_session_id: None,
+            codex_fingerprint_context: None,
             routing_policy: None,
             routing_trace_seed: None,
             routing_context: None,

apps/aether-gateway/src/ai_serving/planner/standard/family/request.rs

@@ -597,6 +597,7 @@ pub(crate) async fn resolve_local_standard_candidate_payload_parts(
     let reasoning_replay_policy = openai_responses_reasoning_replay_policy(
         transport.provider.provider_type.as_str(),
         transport.endpoint.base_url.as_str(),
+        prepared_candidate.mapped_model.as_str(),
     );
     let redaction = resolve_provider_chat_pii_redaction(
         state,

apps/aether-gateway/src/ai_serving/planner/standard/normalize/tests.rs

@@ -102,6 +102,59 @@ fn builds_openai_chat_cross_format_request_body_from_openai_responses_source() {
     assert_eq!(provider_request_body["messages"][0]["content"], "hello");
 }
 
+#[test]
+fn maps_openai_responses_additional_tools_without_message_name() {
+    let body_json = json!({
+        "model": "gpt-5",
+        "input": [
+            {
+                "type": "additional_tools",
+                "role": "developer",
+                "tools": [{
+                    "type": "function",
+                    "name": "get_weather",
+                    "description": "Get the weather",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {}
+                    }
+                }]
+            },
+            {
+                "role": "user",
+                "content": "What is the weather?"
+            }
+        ]
+    });
+
+    let provider_request_body = build_cross_format_openai_responses_request_body(
+        &body_json,
+        "gpt-5-upstream",
+        "openai:responses",
+        "openai:chat",
+        false,
+        false,
+        "openai",
+        None,
+        None,
+        &http::HeaderMap::new(),
+        false,
+    )
+    .expect("Responses additional tools should map to a Chat request body");
+
+    assert_eq!(
+        provider_request_body["messages"].as_array().map(Vec::len),
+        Some(1)
+    );
+    assert_eq!(provider_request_body["messages"][0]["role"], "user");
+    assert!(provider_request_body["messages"][0].get("name").is_none());
+    assert_eq!(provider_request_body["tools"][0]["type"], "function");
+    assert_eq!(
+        provider_request_body["tools"][0]["function"]["name"],
+        "get_weather"
+    );
+}
+
 #[test]
 fn local_openai_responses_wrapper_preserves_body_order_after_edits() {
     let body_json: Value = serde_json::from_str(

apps/aether-gateway/src/ai_serving/planner/standard/openai/chat/decision/request.rs

@@ -159,6 +159,7 @@ fn finalize_openai_chat_provider_request_body(
         openai_responses_reasoning_replay_policy(
             transport.provider.provider_type.as_str(),
             transport.endpoint.base_url.as_str(),
+            mapped_model,
         ),
     )
     .err()
@@ -2182,7 +2183,7 @@ mod tests {
             client_surface: None,
             gateway_credential_carrier: None,
             client_session_affinity: None,
-            original_client_session_id: None,
+            codex_fingerprint_context: None,
             routing_policy: None,
             routing_trace_seed: None,
             routing_context: None,

apps/aether-gateway/src/ai_serving/planner/standard/openai/responses/decision/request.rs

@@ -438,6 +438,7 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts_with_
     let reasoning_replay_policy = openai_responses_reasoning_replay_policy(
         transport.provider.provider_type.as_str(),
         transport.endpoint.base_url.as_str(),
+        mapped_model.as_str(),
     );
     let redaction = resolve_provider_chat_pii_redaction(
         state,

apps/aether-gateway/src/ai_serving/planner/standard/openai/responses/mod.rs

@@ -1005,6 +1005,7 @@ pub(crate) async fn maybe_build_responses_websocket_decision(
                 reasoning_replay_policy: openai_responses_reasoning_replay_policy(
                     transport.provider.provider_type.as_str(),
                     transport.endpoint.base_url.as_str(),
+                    mapped_model.as_str(),
                 ),
                 model_directive_patch: input
                     .model_directive_policy

apps/aether-gateway/src/ai_serving/pure/mod.rs

@@ -181,7 +181,7 @@ pub(crate) use aether_ai_formats::{
     openai_responses_request_operation, openai_responses_synthetic_reasoning_item_id,
     strip_incompatible_openai_responses_reasoning_items,
     strip_incompatible_openai_responses_reasoning_items_with_policy, ApiOperation, ClientSurface,
-    CODEX_CLIENT_VERSION,
+    CODEX_CLIENT_VERSION, OPENAI_RESPONSES_OPERATION_COMPACT,
 };
 
 pub(crate) fn plan_kind_matches_api_operation(

apps/aether-gateway/src/ai_serving/transport.rs

@@ -59,9 +59,9 @@ pub(crate) mod windsurf {
 }
 
 pub(crate) use aether_provider_transport::{
-    append_transport_diagnostics_to_value, apply_codex_oauth_fingerprint_convergence,
-    apply_local_auth_config_header_overrides, apply_local_body_rules,
-    apply_local_body_rules_with_request_headers, apply_local_header_rules,
+    append_transport_diagnostics_to_value, apply_codex_fingerprint_convergence,
+    apply_codex_fingerprint_convergence_with_context, apply_local_auth_config_header_overrides,
+    apply_local_body_rules, apply_local_body_rules_with_request_headers, apply_local_header_rules,
     apply_local_header_rules_with_request_headers, apply_standard_provider_request_body_rules,
     apply_standard_provider_request_body_rules_with_request_headers,
     apply_transport_request_body_semantics, body_rules_are_locally_supported,
@@ -107,8 +107,9 @@ pub(crate) use aether_provider_transport::{
     supports_local_generic_oauth_request_auth_resolution,
     supports_local_oauth_request_auth_resolution, transport_proxy_is_locally_supported,
     transport_supports_api_operation, video_create_transport_unsupported_reason,
-    AnthropicCompatibilityProfile, CandidateTransportPolicyFacts, GatewayProviderTransportSnapshot,
-    GeminiCliRequestAuth, GeminiCliRequestAuthSupport, GeminiCliRequestAuthUnsupportedReason,
+    AnthropicCompatibilityProfile, CandidateTransportPolicyFacts,
+    CodexFingerprintConvergenceContext, GatewayProviderTransportSnapshot, GeminiCliRequestAuth,
+    GeminiCliRequestAuthSupport, GeminiCliRequestAuthUnsupportedReason,
     GeminiCliRequestEnvelopeSupport, GeminiFilesHeadersInput, GeminiFilesRequestBodyError,
     GeminiFilesRequestBodyParts, GrokHeaderInput, LocalResolvedOAuthRequestAuth,
     ProviderOpenAiImageHeadersInput, ProviderVideoCreateFamily, ProviderVideoCreateHeadersInput,