Merge remote-tracking branch 'origin/main' into codex/pool-key-bulk-management-20260714

# Conflicts:
#	apps/aether-gateway/src/handlers/admin/request/provider/tasks.rs
#	frontend/src/api/endpoints/pool.ts

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

@@ -68,6 +68,7 @@ pub(crate) use aether_ai_formats::api::{
     OPENAI_VIDEO_REMIX_SYNC_PLAN_KIND,
 };
 pub(crate) use aether_ai_formats::protocol::stream::CanonicalUsage as StreamingCanonicalUsage;
+pub(crate) use aether_ai_formats::CODEX_RESPONSES_LITE_HEADER;
 
 pub(crate) fn parse_direct_request_body(
     parts: &http::request::Parts,

apps/aether-gateway/src/ai_serving/finalize/tests_sync.rs

@@ -31,6 +31,7 @@ fn test_decision() -> GatewayControlDecision {
         auth_context: None,
         admin_principal: None,
         local_auth_rejection: None,
+        model_directive_policy: Default::default(),
     }
 }
 
@@ -1166,7 +1167,7 @@ fn local_finalize_handles_openai_responses_compact_cross_format_sync_response()
     assert_eq!(report.report_kind, "openai_responses_compact_sync_success");
     assert_eq!(
         report.client_body_json.expect("client body should exist")["object"],
-        "response"
+        "response.compaction"
     );
 }
 
@@ -1222,7 +1223,7 @@ fn local_finalize_handles_openai_responses_compact_cross_format_function_call_re
         .background_report
         .expect("compact tool-call should downgrade to success report");
     let client_body = report.client_body_json.expect("client body should exist");
-    assert_eq!(client_body["object"], "response");
+    assert_eq!(client_body["object"], "response.compaction");
     assert_eq!(client_body["output"][1]["type"], "function_call");
 }
 
@@ -1789,6 +1790,93 @@ fn local_finalize_handles_openai_chat_cross_format_sync_response_from_openai_res
     assert_eq!(client_body["usage"]["total_tokens"], 5);
 }
 
+#[test]
+fn local_finalize_aggregates_openai_responses_capture_envelope_before_chat_conversion() {
+    let payload = GatewaySyncReportRequest {
+        trace_id: "trace-openai-chat-capture-envelope-sync-123".to_string(),
+        report_kind: "openai_chat_sync_finalize".to_string(),
+        report_context: Some(json!({
+            "client_api_format": "openai:chat",
+            "provider_api_format": "openai:responses",
+            "model": "gpt-5.6-luna",
+            "mapped_model": "gpt-5.6-luna",
+            "needs_conversion": true,
+            "has_envelope": false,
+        })),
+        status_code: 200,
+        headers: BTreeMap::from([("content-type".to_string(), "application/json".to_string())]),
+        body_json: Some(json!({
+            "chunks": [
+                {
+                    "type": "response.output_text.delta",
+                    "response_id": "resp_capture_gateway_123",
+                    "output_index": 0,
+                    "content_index": 0,
+                    "delta": "Gateway "
+                },
+                {
+                    "type": "response.output_text.done",
+                    "response_id": "resp_capture_gateway_123",
+                    "output_index": 0,
+                    "content_index": 0,
+                    "text": "Gateway capture"
+                },
+                {
+                    "type": "response.completed",
+                    "response": {
+                        "id": "resp_capture_gateway_123",
+                        "object": "response",
+                        "status": "completed",
+                        "model": "gpt-5.6-luna",
+                        "output": [],
+                        "usage": {
+                            "input_tokens": 2,
+                            "output_tokens": 3,
+                            "total_tokens": 5
+                        }
+                    }
+                }
+            ],
+            "metadata": {}
+        })),
+        client_body_json: None,
+        body_base64: None,
+        telemetry: None,
+    };
+
+    let outcome = maybe_build_local_core_sync_finalize_response(
+        "trace-openai-chat-capture-envelope-sync-123",
+        &test_decision(),
+        &payload,
+    )
+    .expect("capture envelope finalize should succeed")
+    .expect("capture envelope finalize should match");
+
+    let report = outcome
+        .background_report
+        .expect("capture envelope conversion should produce a success report");
+    assert_eq!(report.report_kind, "openai_chat_sync_success");
+    let provider_body = report
+        .body_json
+        .expect("aggregated provider body should exist");
+    assert_eq!(provider_body["id"], "resp_capture_gateway_123");
+    assert_eq!(
+        provider_body["output"][0]["content"][0]["text"],
+        "Gateway capture"
+    );
+    assert!(provider_body.get("chunks").is_none());
+    let client_body = report
+        .client_body_json
+        .expect("converted client body should exist");
+    assert_eq!(
+        client_body["choices"][0]["message"]["content"],
+        "Gateway capture"
+    );
+    assert_eq!(client_body["usage"]["prompt_tokens"], 2);
+    assert_eq!(client_body["usage"]["completion_tokens"], 3);
+    assert_eq!(client_body["usage"]["total_tokens"], 5);
+}
+
 #[test]
 fn local_finalize_handles_claude_chat_cross_format_sync_response_from_openai_chat() {
     let payload = GatewaySyncReportRequest {
@@ -1841,6 +1929,7 @@ fn local_finalize_handles_claude_chat_cross_format_sync_response_from_openai_cha
             auth_context: None,
             admin_principal: None,
             local_auth_rejection: None,
+            model_directive_policy: Default::default(),
         },
         &payload,
     )
@@ -1908,6 +1997,7 @@ fn local_finalize_handles_gemini_cli_cross_format_sync_response_from_claude_cli(
             auth_context: None,
             admin_principal: None,
             local_auth_rejection: None,
+            model_directive_policy: Default::default(),
         },
         &payload,
     )

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

@@ -13,7 +13,9 @@ use crate::{usage::GatewaySyncReportRequest, AppState, GatewayError};
 pub(crate) use self::adaptation::{
     maybe_build_provider_private_stream_normalizer, ProviderPrivateStreamNormalizer,
 };
-pub(crate) use self::api::gemini_generate_content_response_has_visible_output;
+pub(crate) use self::api::{
+    gemini_generate_content_response_has_visible_output, CODEX_RESPONSES_LITE_HEADER,
+};
 pub(crate) use self::finalize::common::LocalCoreSyncFinalizeOutcome;
 pub(crate) use self::finalize::internal::{
     maybe_bridge_standard_sync_json_to_stream, maybe_build_stream_response_rewriter,
@@ -48,16 +50,17 @@ pub(crate) use self::planner::{
     build_standard_family_stream_plan_and_reports, build_standard_family_sync_attempt_source,
     build_standard_family_sync_plan_and_reports, build_standard_stream_plan_from_decision,
     build_standard_sync_plan_from_decision, candidate_auth_channel_skip_reason,
-    extract_pool_sticky_session_token, maybe_build_stream_decision_payload,
-    maybe_build_stream_plan_payload, maybe_build_sync_decision_payload,
-    maybe_build_sync_plan_payload, planner_is_matching_stream_request, provider_key_pool_score_id,
-    provider_key_pool_score_scope, read_candidate_transport_snapshot,
-    record_local_runtime_candidate_skip_reason,
-    set_local_openai_chat_execution_exhausted_diagnostic,
-    set_local_openai_image_execution_exhausted_diagnostic, CandidateFailureDiagnostic,
-    CandidateFailureDiagnosticKind, EligibleLocalExecutionCandidate, GatewayAuthApiKeySnapshot,
-    GatewayProviderTransportSnapshot, LocalExecutionAttemptSource, LocalExecutionCandidateKind,
-    LocalResolvedOAuthRequestAuth, PlannerAppState, SkippedLocalExecutionCandidate,
+    codex_model_capabilities_for_transport, extract_pool_sticky_session_token,
+    maybe_build_stream_decision_payload, maybe_build_stream_plan_payload,
+    maybe_build_sync_decision_payload, maybe_build_sync_plan_payload,
+    planner_is_matching_stream_request, provider_key_pool_score_id, provider_key_pool_score_scope,
+    read_candidate_transport_snapshot, record_local_runtime_candidate_skip_reason,
+    resolve_upstream_is_stream_for_provider, set_local_openai_chat_execution_exhausted_diagnostic,
+    set_local_openai_image_execution_exhausted_diagnostic, validate_final_openai_provider_request,
+    CandidateFailureDiagnostic, CandidateFailureDiagnosticKind, EligibleLocalExecutionCandidate,
+    GatewayAuthApiKeySnapshot, GatewayProviderTransportSnapshot, LocalExecutionAttemptSource,
+    LocalExecutionCandidateKind, LocalResolvedOAuthRequestAuth, PlannerAppState,
+    SkippedLocalExecutionCandidate,
 };
 pub(crate) use self::pure::*;
 pub(crate) use self::transport::{

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

@@ -702,9 +702,11 @@ pub(crate) async fn build_lazy_requested_model_execution_candidate_attempt_sourc
     G,
 >(
     state: PlannerAppState<'a>,
+    model_directive_policy: &crate::system_features::ModelDirectivePolicySnapshot,
     trace_id: &str,
     client_api_format: &str,
     requested_model: &str,
+    request_operation: Option<&str>,
     require_streaming: bool,
     auth_snapshot: &GatewayAuthApiKeySnapshot,
     client_session_affinity: Option<&ClientSessionAffinity>,
@@ -730,8 +732,10 @@ where
     let record_runtime_miss_diagnostic = persistence_policy.skipped.record_runtime_miss_diagnostic;
     let page_cursor = LocalCandidatePreselectionPageCursor::new(
         state,
+        model_directive_policy,
         client_api_format,
         requested_model,
+        request_operation,
         require_streaming,
         required_capabilities,
         auth_snapshot,
@@ -1139,6 +1143,7 @@ async fn resolve_priority_candidate_page_with_cache(
 
     let key = CandidateResolvedPageCacheKey::new(
         &cursor.requested_model,
+        cursor.page_cursor.resolved_page_cache_request_operation(),
         &cursor.client_api_format,
         true,
         &cursor.auth_snapshot,
@@ -1151,6 +1156,9 @@ async fn resolve_priority_candidate_page_with_cache(
             .page_cursor
             .resolved_page_cache_use_api_format_alias_match(),
         cursor.client_session_affinity.as_ref(),
+        cursor
+            .page_cursor
+            .resolved_page_cache_model_directive_policy_hash(),
         cursor.resolution_mode,
     );
     let page_candidates_for_fallback = page_candidates.clone();
@@ -1949,6 +1957,7 @@ mod tests {
             global_model_id: "global-model-1".to_string(),
             global_model_name: "gpt-5".to_string(),
             selected_provider_model_name: "gpt-5".to_string(),
+            supports_streaming: true,
             mapping_matched_model: None,
         }
     }
@@ -2177,10 +2186,14 @@ mod tests {
     async fn resolved_candidate_page_cache_requires_fixed_order_or_explicit_affinity() {
         let app = AppState::new().expect("state should build");
         let auth_snapshot = sample_auth_snapshot();
+        let model_directive_policy =
+            crate::system_features::ModelDirectivePolicySnapshot::default();
         let mut page_cursor = LocalCandidatePreselectionPageCursor::new(
             PlannerAppState::new(&app),
+            &model_directive_policy,
             "openai:chat",
             "gpt-5",
+            None,
             true,
             None,
             &auth_snapshot,
@@ -2233,8 +2246,10 @@ mod tests {
 
         let mut page_cursor = LocalCandidatePreselectionPageCursor::new(
             PlannerAppState::new(&app),
+            &model_directive_policy,
             "openai:chat",
             "gpt-5",
+            None,
             true,
             None,
             &auth_snapshot,
@@ -2269,8 +2284,10 @@ mod tests {
             );
         let mut page_cursor = LocalCandidatePreselectionPageCursor::new(
             PlannerAppState::new(&fixed_order_app),
+            &model_directive_policy,
             "openai:chat",
             "gpt-5",
+            None,
             true,
             None,
             &auth_snapshot,

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

@@ -134,6 +134,7 @@ mod tests {
             global_model_id: "global-1".to_string(),
             global_model_name: "gpt-5.4".to_string(),
             selected_provider_model_name: "gpt-5.4".to_string(),
+            supports_streaming: true,
             mapping_matched_model: None,
         }
     }

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

@@ -169,6 +169,7 @@ mod tests {
             global_model_id: "global-model-1".to_string(),
             global_model_name: "gpt-test".to_string(),
             selected_provider_model_name: "gpt-test-upstream".to_string(),
+            supports_streaming: true,
             mapping_matched_model: None,
         }
     }

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

@@ -348,6 +348,7 @@ mod tests {
             global_model_id: "global-model-1".to_string(),
             global_model_name: "gpt-4.1".to_string(),
             selected_provider_model_name: "gpt-4.1".to_string(),
+            supports_streaming: true,
             mapping_matched_model: None,
         }
     }
@@ -624,6 +625,7 @@ mod tests {
             global_model_id: "global-model-1".to_string(),
             global_model_name: "gpt-4.1".to_string(),
             selected_provider_model_name: "gpt-4.1".to_string(),
+            supports_streaming: true,
             mapping_matched_model: None,
         }
     }

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

@@ -643,6 +643,7 @@ mod tests {
             global_model_id: "global-model-1".to_string(),
             global_model_name: "claude-sonnet".to_string(),
             selected_provider_model_name: "claude-sonnet".to_string(),
+            supports_streaming: true,
             mapping_matched_model: None,
         }
     }

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

@@ -6,9 +6,10 @@ use aether_routing_core::ResolvedRoutingPolicy;
 use aether_runtime::ConcurrencyPermit;
 use aether_scheduler_core::{
     enumerate_minimal_candidate_selection_with_model_directives, normalize_api_format,
-    resolve_requested_global_model_name_with_model_directives,
-    row_supports_requested_model_with_model_directives, ClientSessionAffinity,
-    EnumerateMinimalCandidateSelectionInput, SchedulerMinimalCandidateSelectionCandidate,
+    resolve_requested_global_model_name_with_model_directives_and_request_operation,
+    row_supports_requested_model_with_model_directives_and_request_operation,
+    ClientSessionAffinity, EnumerateMinimalCandidateSelectionInput,
+    SchedulerMinimalCandidateSelectionCandidate,
 };
 use async_trait::async_trait;
 use std::collections::{BTreeMap, BTreeSet, VecDeque};
@@ -56,6 +57,7 @@ struct GatewayLocalCandidatePreselectionPort<'a> {
     state: PlannerAppState<'a>,
     client_api_format: &'a str,
     requested_model: &'a str,
+    request_operation: Option<&'a str>,
     require_streaming: bool,
     required_capabilities: Option<&'a serde_json::Value>,
     auth_snapshot: &'a GatewayAuthApiKeySnapshot,
@@ -64,10 +66,25 @@ struct GatewayLocalCandidatePreselectionPort<'a> {
     use_api_format_alias_match: bool,
     key_mode: LocalCandidatePreselectionKeyMode,
     candidate_api_formats: Vec<String>,
-    model_directive_enabled_api_formats: BTreeSet<String>,
+    model_directive_routing_models: BTreeMap<String, String>,
     ranking_seed: u64,
 }
 
+impl GatewayLocalCandidatePreselectionPort<'_> {
+    fn model_directive_base_model(&self, candidate_api_format: &str) -> Option<&str> {
+        self.model_directive_routing_models
+            .get(&crate::ai_serving::normalize_api_format_alias(
+                candidate_api_format,
+            ))
+            .map(String::as_str)
+    }
+
+    fn routing_model(&self, candidate_api_format: &str) -> &str {
+        self.model_directive_base_model(candidate_api_format)
+            .unwrap_or(self.requested_model)
+    }
+}
+
 #[async_trait]
 impl AiCandidatePreselectionPort for GatewayLocalCandidatePreselectionPort<'_> {
     type Candidate = SchedulerMinimalCandidateSelectionCandidate;
@@ -97,14 +114,16 @@ impl AiCandidatePreselectionPort for GatewayLocalCandidatePreselectionPort<'_> {
         let auth_snapshot = matches_client_format.then_some(self.auth_snapshot);
         let (candidates, skipped_candidates) = self
             .state
-            .list_selectable_candidates_with_skip_reasons(
+            .list_selectable_candidates_with_skip_reasons_for_request_operation(
                 candidate_api_format,
-                self.requested_model,
+                self.routing_model(candidate_api_format),
                 self.require_streaming,
                 self.required_capabilities,
                 auth_snapshot,
                 self.client_session_affinity,
                 self.ranking_seed,
+                false,
+                self.request_operation,
             )
             .await?;
 
@@ -123,16 +142,13 @@ impl AiCandidatePreselectionPort for GatewayLocalCandidatePreselectionPort<'_> {
         candidate_api_format: &str,
         matches_client_format: bool,
     ) -> bool {
-        let enable_model_directives = self.model_directive_enabled_api_formats.contains(
-            &crate::ai_serving::normalize_api_format_alias(candidate_api_format),
-        );
         routing_policy_allows_provider(self.routing_policy, candidate)
             && (matches_client_format
                 || auth_snapshot_allows_cross_format_candidate(
                     self.auth_snapshot,
                     self.requested_model,
+                    self.model_directive_base_model(candidate_api_format),
                     candidate,
-                    enable_model_directives,
                 ))
     }
 
@@ -142,16 +158,13 @@ impl AiCandidatePreselectionPort for GatewayLocalCandidatePreselectionPort<'_> {
         candidate_api_format: &str,
         matches_client_format: bool,
     ) -> bool {
-        let enable_model_directives = self.model_directive_enabled_api_formats.contains(
-            &crate::ai_serving::normalize_api_format_alias(candidate_api_format),
-        );
         routing_policy_allows_provider(self.routing_policy, &skipped_candidate.candidate)
             && (matches_client_format
                 || auth_snapshot_allows_cross_format_candidate(
                     self.auth_snapshot,
                     self.requested_model,
+                    self.model_directive_base_model(candidate_api_format),
                     &skipped_candidate.candidate,
-                    enable_model_directives,
                 ))
     }
 
@@ -164,11 +177,30 @@ impl AiCandidatePreselectionPort for GatewayLocalCandidatePreselectionPort<'_> {
     }
 }
 
+fn resolve_model_directive_routing_models(
+    policy: &crate::system_features::ModelDirectivePolicySnapshot,
+    candidate_api_formats: &[String],
+    requested_model: &str,
+) -> BTreeMap<String, String> {
+    candidate_api_formats
+        .iter()
+        .filter_map(|api_format| {
+            let api_format = crate::ai_serving::normalize_api_format_alias(api_format);
+            let resolution = policy.resolve_reasoning(&api_format, Some(requested_model));
+            resolution
+                .base_model()
+                .map(|base_model| (api_format, base_model.to_string()))
+        })
+        .collect()
+}
+
 #[allow(clippy::too_many_arguments)]
 pub(crate) async fn preselect_local_execution_candidates_with_serving(
     state: PlannerAppState<'_>,
+    model_directive_policy: &crate::system_features::ModelDirectivePolicySnapshot,
     client_api_format: &str,
     requested_model: &str,
+    request_operation: Option<&str>,
     require_streaming: bool,
     required_capabilities: Option<&serde_json::Value>,
     auth_snapshot: &GatewayAuthApiKeySnapshot,
@@ -190,8 +222,10 @@ pub(crate) async fn preselect_local_execution_candidates_with_serving(
             .collect::<Vec<_>>();
     preselect_local_execution_candidates_for_api_formats_with_serving(
         state,
+        model_directive_policy,
         client_api_format,
         requested_model,
+        request_operation,
         require_streaming,
         required_capabilities,
         auth_snapshot,
@@ -207,8 +241,10 @@ pub(crate) async fn preselect_local_execution_candidates_with_serving(
 #[allow(clippy::too_many_arguments)]
 pub(crate) async fn preselect_local_execution_candidates_for_api_formats_with_serving(
     state: PlannerAppState<'_>,
+    model_directive_policy: &crate::system_features::ModelDirectivePolicySnapshot,
     client_api_format: &str,
     requested_model: &str,
+    request_operation: Option<&str>,
     require_streaming: bool,
     required_capabilities: Option<&serde_json::Value>,
     auth_snapshot: &GatewayAuthApiKeySnapshot,
@@ -224,23 +260,16 @@ pub(crate) async fn preselect_local_execution_candidates_for_api_formats_with_se
     >,
     GatewayError,
 > {
-    let mut model_directive_enabled_api_formats = BTreeSet::new();
-    for api_format in &candidate_api_formats {
-        if crate::system_features::reasoning_model_directive_enabled_for_api_format_and_model(
-            state.app(),
-            api_format,
-            Some(requested_model),
-        )
-        .await
-        {
-            model_directive_enabled_api_formats
-                .insert(crate::ai_serving::normalize_api_format_alias(api_format));
-        }
-    }
+    let model_directive_routing_models = resolve_model_directive_routing_models(
+        model_directive_policy,
+        &candidate_api_formats,
+        requested_model,
+    );
     let port = GatewayLocalCandidatePreselectionPort {
         state,
         client_api_format,
         requested_model,
+        request_operation,
         require_streaming,
         required_capabilities,
         auth_snapshot,
@@ -249,7 +278,7 @@ pub(crate) async fn preselect_local_execution_candidates_for_api_formats_with_se
         use_api_format_alias_match,
         key_mode,
         candidate_api_formats,
-        model_directive_enabled_api_formats,
+        model_directive_routing_models,
         ranking_seed: request_distribution_seed(),
     };
 
@@ -261,6 +290,7 @@ pub(crate) struct LocalCandidatePreselectionPageCursor<'a> {
     trace_id: String,
     client_api_format: String,
     requested_model: String,
+    request_operation: Option<String>,
     require_streaming: bool,
     required_capabilities: Option<serde_json::Value>,
     auth_snapshot: GatewayAuthApiKeySnapshot,
@@ -271,7 +301,8 @@ pub(crate) struct LocalCandidatePreselectionPageCursor<'a> {
     key_mode: LocalCandidatePreselectionKeyMode,
     allow_priority_page_cache: bool,
     candidate_api_formats: Vec<String>,
-    model_directive_enabled_api_formats: BTreeSet<String>,
+    model_directive_routing_models: BTreeMap<String, String>,
+    model_directive_policy_cache_key: String,
     ordering_config: SchedulerOrderingConfig,
     ranking_seed: u64,
     priority_page_emitted: bool,
@@ -294,11 +325,26 @@ pub(crate) struct LocalCandidatePreselectionPageCursor<'a> {
 }
 
 impl<'a> LocalCandidatePreselectionPageCursor<'a> {
+    fn model_directive_base_model(&self, candidate_api_format: &str) -> Option<&str> {
+        self.model_directive_routing_models
+            .get(&crate::ai_serving::normalize_api_format_alias(
+                candidate_api_format,
+            ))
+            .map(String::as_str)
+    }
+
+    fn routing_model(&self, candidate_api_format: &str) -> &str {
+        self.model_directive_base_model(candidate_api_format)
+            .unwrap_or(&self.requested_model)
+    }
+
     #[allow(clippy::too_many_arguments)]
     pub(crate) async fn new(
         state: PlannerAppState<'a>,
+        model_directive_policy: &crate::system_features::ModelDirectivePolicySnapshot,
         client_api_format: &str,
         requested_model: &str,
+        request_operation: Option<&str>,
         require_streaming: bool,
         required_capabilities: Option<&serde_json::Value>,
         auth_snapshot: &GatewayAuthApiKeySnapshot,
@@ -315,19 +361,11 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
                 .into_iter()
                 .map(str::to_string)
                 .collect::<Vec<_>>();
-        let mut model_directive_enabled_api_formats = BTreeSet::new();
-        for api_format in &candidate_api_formats {
-            if crate::system_features::reasoning_model_directive_enabled_for_api_format_and_model(
-                state.app(),
-                api_format,
-                Some(requested_model),
-            )
-            .await
-            {
-                model_directive_enabled_api_formats
-                    .insert(crate::ai_serving::normalize_api_format_alias(api_format));
-            }
-        }
+        let model_directive_routing_models = resolve_model_directive_routing_models(
+            model_directive_policy,
+            &candidate_api_formats,
+            requested_model,
+        );
 
         let ordering_config =
             super::candidate_ranking::scheduler_ordering_config_for_routing_policy(
@@ -341,6 +379,7 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
             trace_id: trace_id.unwrap_or_default().to_string(),
             client_api_format: client_api_format.to_string(),
             requested_model: requested_model.to_string(),
+            request_operation: request_operation.map(str::to_string),
             require_streaming,
             required_capabilities: required_capabilities.cloned(),
             auth_snapshot: auth_snapshot.clone(),
@@ -351,7 +390,8 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
             key_mode,
             allow_priority_page_cache,
             candidate_api_formats,
-            model_directive_enabled_api_formats,
+            model_directive_routing_models,
+            model_directive_policy_cache_key: model_directive_policy.cache_key().to_string(),
             ordering_config,
             ranking_seed: request_distribution_seed(),
             priority_page_emitted: false,
@@ -422,10 +462,18 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
         self.key_mode.cache_key_name()
     }
 
+    pub(crate) fn resolved_page_cache_request_operation(&self) -> Option<&str> {
+        self.request_operation.as_deref()
+    }
+
     pub(crate) fn resolved_page_cache_use_api_format_alias_match(&self) -> bool {
         self.use_api_format_alias_match
     }
 
+    pub(crate) fn resolved_page_cache_model_directive_policy_hash(&self) -> &str {
+        &self.model_directive_policy_cache_key
+    }
+
     pub(crate) fn should_cache_current_priority_resolved_page(&self) -> bool {
         if !(self.priority_page_emitted
             && self.format_index == 0
@@ -481,6 +529,7 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
     > {
         let key = CandidatePageCacheKey::new(
             &self.requested_model,
+            self.request_operation.as_deref(),
             &self.client_api_format,
             self.require_streaming,
             &self.auth_snapshot,
@@ -491,6 +540,7 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
             self.key_mode.cache_key_name(),
             self.use_api_format_alias_match,
             self.client_session_affinity.as_ref(),
+            &self.model_directive_policy_cache_key,
         );
         let cache = self.state.app().candidate_page_cache.clone();
         let ttl = candidate_page_cache_ttl_from_env();
@@ -752,11 +802,8 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
         if normalized_api_format.is_empty() {
             return Ok(None);
         }
-        let enable_model_directives = self.model_directive_enabled_api_formats.contains(
-            &crate::ai_serving::normalize_api_format_alias(candidate_api_format),
-        );
-        let requested_names =
-            requested_model_candidate_names(&self.requested_model, enable_model_directives);
+        let routing_model = self.routing_model(candidate_api_format).to_string();
+        let requested_names = requested_model_candidate_names(&routing_model, false);
         let scanned = *self
             .scanned_rows_by_format
             .get(&normalized_api_format)
@@ -772,11 +819,7 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
                 .or_insert(0);
             let Some(requested_name) = requested_names.get(requested_name_index) else {
                 return self
-                    .next_fallback_page_for_api_format(
-                        candidate_api_format,
-                        &normalized_api_format,
-                        enable_model_directives,
-                    )
+                    .next_fallback_page_for_api_format(candidate_api_format, &normalized_api_format)
                     .await;
             };
             if requested_name.trim().is_empty() {
@@ -803,9 +846,9 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
                 .read_requested_model_rows_fast_path_page_cached(
                     &normalized_api_format,
                     requested_name,
+                    &routing_model,
                     offset,
                     limit,
-                    enable_model_directives,
                 )
                 .await?;
             self.scanned_rows_by_format.insert(
@@ -824,7 +867,6 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
                         .next_fallback_page_for_api_format(
                             candidate_api_format,
                             &normalized_api_format,
-                            enable_model_directives,
                         )
                         .await;
                 }
@@ -835,7 +877,6 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
                 .build_page_outcome_from_rows(
                     candidate_api_format,
                     &normalized_api_format,
-                    enable_model_directives,
                     page.rows,
                 )
                 .await?
@@ -849,17 +890,17 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
         &self,
         normalized_api_format: &str,
         requested_name: &str,
+        routing_model: &str,
         offset: u32,
         limit: u32,
-        enable_model_directives: bool,
     ) -> Result<RequestedModelCandidateRowsPage, GatewayError> {
         let key = CandidateRowPageCacheKey::new(
             normalized_api_format,
-            &self.requested_model,
+            routing_model,
             requested_name,
             offset,
             limit,
-            enable_model_directives,
+            false,
         );
         let cache = self.state.app().candidate_row_page_cache.clone();
         let ttl = candidate_page_cache_ttl_from_env();
@@ -873,11 +914,11 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
                     let page = read_requested_model_rows_fast_path_page(
                         self.state.app().data.as_ref(),
                         normalized_api_format,
-                        &self.requested_model,
+                        routing_model,
                         requested_name,
                         offset,
                         limit,
-                        enable_model_directives,
+                        false,
                     )
                     .await
                     .map_err(|err| GatewayError::Internal(err.to_string()))?;
@@ -913,7 +954,6 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
         &mut self,
         candidate_api_format: &str,
         normalized_api_format: &str,
-        enable_model_directives: bool,
     ) -> Result<
         Option<
             AiCandidatePreselectionOutcome<
@@ -930,6 +970,7 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
             return Ok(None);
         }
 
+        let routing_model = self.routing_model(candidate_api_format).to_string();
         let rows = self
             .state
             .app()
@@ -939,29 +980,24 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
             .map_err(|err| GatewayError::Internal(err.to_string()))?
             .into_iter()
             .filter(|row| {
-                row_supports_requested_model_with_model_directives(
+                row_supports_requested_model_with_model_directives_and_request_operation(
                     row,
-                    &self.requested_model,
+                    &routing_model,
                     normalized_api_format,
-                    enable_model_directives,
+                    false,
+                    self.request_operation.as_deref(),
                 )
             })
             .collect::<Vec<_>>();
 
-        self.build_page_outcome_from_rows(
-            candidate_api_format,
-            normalized_api_format,
-            enable_model_directives,
-            rows,
-        )
-        .await
+        self.build_page_outcome_from_rows(candidate_api_format, normalized_api_format, rows)
+            .await
     }
 
     async fn build_page_outcome_from_rows(
         &mut self,
         candidate_api_format: &str,
         normalized_api_format: &str,
-        enable_model_directives: bool,
         rows: Vec<StoredMinimalCandidateSelectionRow>,
     ) -> Result<
         Option<
@@ -984,16 +1020,20 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
         if rows.is_empty() {
             return Ok(None);
         }
+        let routing_model = self.routing_model(candidate_api_format).to_string();
         let resolved_global_model_name =
             if let Some(value) = self.resolved_global_model_names.get(normalized_api_format) {
                 value.clone()
             } else {
-                let Some(value) = resolve_requested_global_model_name_with_model_directives(
-                    &rows,
-                    &self.requested_model,
-                    normalized_api_format,
-                    enable_model_directives,
-                ) else {
+                let Some(value) =
+                    resolve_requested_global_model_name_with_model_directives_and_request_operation(
+                        &rows,
+                        &routing_model,
+                        normalized_api_format,
+                        false,
+                        self.request_operation.as_deref(),
+                    )
+                else {
                     return Ok(None);
                 };
                 self.resolved_global_model_names
@@ -1016,22 +1056,19 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
             EnumerateMinimalCandidateSelectionInput {
                 rows,
                 normalized_api_format,
-                requested_model_name: &self.requested_model,
+                request_operation: self.request_operation.as_deref(),
+                requested_model_name: &routing_model,
                 resolved_global_model_name: resolved_global_model_name.as_str(),
                 require_streaming: self.require_streaming,
                 required_capabilities: self.required_capabilities.as_ref(),
                 auth_constraints: auth_constraints.as_ref(),
             },
-            enable_model_directives,
+            false,
         )
         .map_err(|err| GatewayError::Internal(err.to_string()))?;
         let mut candidates = Vec::new();
         for candidate in enumerated_candidates {
-            if !self.candidate_allowed_for_page(
-                &candidate,
-                candidate_api_format,
-                enable_model_directives,
-            ) {
+            if !self.candidate_allowed_for_page(&candidate, candidate_api_format) {
                 continue;
             }
             if !self
@@ -1065,11 +1102,7 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
             .into_iter()
             .map(skipped_local_execution_candidate_from_scheduler_skip)
             .filter(|skipped_candidate| {
-                self.skipped_candidate_allowed_for_page(
-                    skipped_candidate,
-                    candidate_api_format,
-                    enable_model_directives,
-                )
+                self.skipped_candidate_allowed_for_page(skipped_candidate, candidate_api_format)
             })
             .collect::<Vec<_>>();
 
@@ -1083,7 +1116,6 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
         &self,
         candidate: &SchedulerMinimalCandidateSelectionCandidate,
         candidate_api_format: &str,
-        enable_model_directives: bool,
     ) -> bool {
         routing_policy_allows_provider(self.routing_policy.as_ref(), candidate)
             && (matches_client_api_format(
@@ -1093,8 +1125,8 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
             ) || auth_snapshot_allows_cross_format_candidate(
                 &self.auth_snapshot,
                 &self.requested_model,
+                self.model_directive_base_model(candidate_api_format),
                 candidate,
-                enable_model_directives,
             ))
     }
 
@@ -1102,7 +1134,6 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
         &self,
         skipped_candidate: &SkippedLocalExecutionCandidate,
         candidate_api_format: &str,
-        enable_model_directives: bool,
     ) -> bool {
         routing_policy_allows_provider(self.routing_policy.as_ref(), &skipped_candidate.candidate)
             && (matches_client_api_format(
@@ -1112,8 +1143,8 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
             ) || auth_snapshot_allows_cross_format_candidate(
                 &self.auth_snapshot,
                 &self.requested_model,
+                self.model_directive_base_model(candidate_api_format),
                 &skipped_candidate.candidate,
-                enable_model_directives,
             ))
     }
 }
@@ -1199,8 +1230,8 @@ fn matches_client_api_format(
 pub(crate) fn auth_snapshot_allows_cross_format_candidate(
     auth_snapshot: &GatewayAuthApiKeySnapshot,
     requested_model: &str,
+    requested_base_model: Option<&str>,
     candidate: &SchedulerMinimalCandidateSelectionCandidate,
-    enable_model_directives: bool,
 ) -> bool {
     if let Some(allowed_providers) = auth_snapshot.effective_allowed_providers() {
         let provider_allowed = allowed_providers.iter().any(|value| {
@@ -1217,15 +1248,10 @@ pub(crate) fn auth_snapshot_allows_cross_format_candidate(
     }
 
     if let Some(allowed_models) = auth_snapshot.effective_allowed_models() {
-        let requested_base_model = enable_model_directives
-            .then(|| crate::ai_serving::model_directive_base_model(requested_model))
-            .flatten();
         let model_allowed = allowed_models.iter().any(|value| {
             value == requested_model
                 || value == &candidate.global_model_name
-                || requested_base_model
-                    .as_ref()
-                    .is_some_and(|base_model| value == base_model)
+                || requested_base_model.is_some_and(|base_model| value == base_model)
         });
         if !model_allowed {
             return false;
@@ -1303,10 +1329,14 @@ mod tests {
             .expect("gateway state should build")
             .with_data_state_for_tests(data_state);
         let auth_snapshot = unrestricted_auth_snapshot();
+        let model_directive_policy =
+            crate::system_features::ModelDirectivePolicySnapshot::load(&app).await;
         let mut cursor = LocalCandidatePreselectionPageCursor::new(
             PlannerAppState::new(&app),
+            &model_directive_policy,
             "openai:chat",
             "gpt-5",
+            None,
             true,
             None,
             &auth_snapshot,
@@ -1522,6 +1552,7 @@ mod tests {
                 priority: 1,
                 api_formats: None,
                 endpoint_ids: Some(vec!["endpoint-opg-openai".to_string()]),
+                operations: None,
             }]),
             model_supports_streaming: Some(true),
             model_is_active: true,
@@ -1545,10 +1576,14 @@ mod tests {
             .expect("gateway state should build")
             .with_data_state_for_tests(data_state);
         let auth_snapshot = unrestricted_auth_snapshot();
+        let model_directive_policy =
+            crate::system_features::ModelDirectivePolicySnapshot::load(&app).await;
         let mut cursor = LocalCandidatePreselectionPageCursor::new(
             PlannerAppState::new(&app),
+            &model_directive_policy,
             "claude:messages",
             "gpt-5.5-xhigh",
+            None,
             false,
             None,
             &auth_snapshot,
@@ -1578,6 +1613,142 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn paged_preselection_prefers_operation_scoped_mapping_for_compaction() {
+        let mut row = openai_responses_mapping_row();
+        row.global_model_mappings = None;
+        row.global_model_name = "gpt-5.6-sol".to_string();
+        row.model_provider_model_name = "gpt-5.6-sol".to_string();
+        row.model_provider_model_mappings = Some(vec![
+            StoredProviderModelMapping {
+                name: "gpt-5.6-sol".to_string(),
+                priority: 1,
+                api_formats: Some(vec!["openai:responses".to_string()]),
+                endpoint_ids: None,
+                operations: None,
+            },
+            StoredProviderModelMapping {
+                name: "gpt-5.6-terra".to_string(),
+                priority: 1,
+                api_formats: Some(vec!["openai:responses".to_string()]),
+                endpoint_ids: None,
+                operations: Some(vec!["compact".to_string()]),
+            },
+        ]);
+        let repository: Arc<dyn MinimalCandidateSelectionReadRepository> =
+            Arc::new(InMemoryMinimalCandidateSelectionReadRepository::seed([row]));
+        let data_state =
+            GatewayDataState::with_minimal_candidate_selection_reader_for_tests(repository);
+        let app = AppState::new()
+            .expect("gateway state should build")
+            .with_data_state_for_tests(data_state);
+        let auth_snapshot = unrestricted_auth_snapshot();
+        let model_directive_policy =
+            crate::system_features::ModelDirectivePolicySnapshot::load(&app).await;
+        let mut cursor = LocalCandidatePreselectionPageCursor::new(
+            PlannerAppState::new(&app),
+            &model_directive_policy,
+            "openai:responses",
+            "gpt-5.6-sol",
+            Some("compact"),
+            false,
+            None,
+            &auth_snapshot,
+            None,
+            None,
+            None,
+            true,
+            LocalCandidatePreselectionKeyMode::ProviderEndpointKeyModelAndApiFormat,
+            true,
+            None,
+        )
+        .await;
+
+        let page = cursor
+            .next_page()
+            .await
+            .expect("preselection should succeed")
+            .expect("compact mapping should find a provider");
+
+        assert_eq!(page.candidates.len(), 1);
+        assert_eq!(
+            page.candidates[0].selected_provider_model_name,
+            "gpt-5.6-terra"
+        );
+    }
+
+    #[tokio::test]
+    async fn custom_policy_suffix_uses_the_same_base_model_for_candidate_selection() {
+        let mut row = openai_responses_mapping_row();
+        row.global_model_name = "deployment-alias".to_string();
+        row.global_model_mappings = None;
+        row.model_provider_model_name = "gpt-5.6-sol".to_string();
+        let repository: Arc<dyn MinimalCandidateSelectionReadRepository> =
+            Arc::new(InMemoryMinimalCandidateSelectionReadRepository::seed([row]));
+        let data_state =
+            GatewayDataState::with_minimal_candidate_selection_reader_for_tests(repository)
+                .with_system_config_values_for_tests([
+                    (
+                        crate::system_features::ENABLE_MODEL_DIRECTIVES_CONFIG_KEY.to_string(),
+                        serde_json::json!(true),
+                    ),
+                    (
+                        crate::system_features::MODEL_DIRECTIVES_CONFIG_KEY.to_string(),
+                        serde_json::json!({
+                            "reasoning_effort": {
+                                "api_formats": {
+                                    "openai:responses": {
+                                        "suffixes": ["VendorFuture"],
+                                        "mappings": {
+                                            "VendorFuture": {
+                                                "reasoning": { "context": "all_turns" }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }),
+                    ),
+                ]);
+        let app = AppState::new()
+            .expect("gateway state should build")
+            .with_data_state_for_tests(data_state);
+        let auth_snapshot = unrestricted_auth_snapshot();
+        let model_directive_policy =
+            crate::system_features::ModelDirectivePolicySnapshot::load(&app).await;
+        let mut cursor = LocalCandidatePreselectionPageCursor::new(
+            PlannerAppState::new(&app),
+            &model_directive_policy,
+            "openai:responses",
+            "deployment-alias-VendorFuture",
+            None,
+            false,
+            None,
+            &auth_snapshot,
+            None,
+            None,
+            None,
+            true,
+            LocalCandidatePreselectionKeyMode::ProviderEndpointKeyModelAndApiFormat,
+            true,
+            None,
+        )
+        .await;
+
+        let page = cursor
+            .next_page()
+            .await
+            .expect("preselection should succeed")
+            .expect("custom directive base model should resolve a candidate");
+
+        assert_eq!(page.candidates.len(), 1);
+        assert_eq!(page.candidates[0].global_model_name, "deployment-alias");
+        assert_eq!(
+            page.candidates[0].selected_provider_model_name,
+            "gpt-5.6-sol"
+        );
+    }
+
     #[tokio::test]
     async fn claude_request_uses_cross_format_key_when_same_provider_messages_key_lacks_model() {
         let repository: Arc<dyn MinimalCandidateSelectionReadRepository> =
@@ -1605,10 +1776,14 @@ mod tests {
             .expect("gateway state should build")
             .with_data_state_for_tests(data_state);
         let auth_snapshot = unrestricted_auth_snapshot();
+        let model_directive_policy =
+            crate::system_features::ModelDirectivePolicySnapshot::load(&app).await;
         let mut cursor = LocalCandidatePreselectionPageCursor::new(
             PlannerAppState::new(&app),
+            &model_directive_policy,
             "claude:messages",
             "deepseek-v4-pro",
+            None,
             false,
             None,
             &auth_snapshot,
@@ -1680,10 +1855,14 @@ mod tests {
             .expect("gateway state should build")
             .with_data_state_for_tests(data_state);
         let auth_snapshot = unrestricted_auth_snapshot();
+        let model_directive_policy =
+            crate::system_features::ModelDirectivePolicySnapshot::load(&app).await;
         let mut cursor = LocalCandidatePreselectionPageCursor::new(
             PlannerAppState::new(&app),
+            &model_directive_policy,
             "claude:messages",
             "gpt-5",
+            None,
             false,
             None,
             &auth_snapshot,

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

@@ -1,11 +1,12 @@
 use axum::body::Bytes;
 
+use crate::ai_serving::is_json_request;
 use crate::ai_serving::{
     endpoint_config_forces_upstream_stream_policy as endpoint_config_forces_upstream_stream_policy_impl,
     enforce_request_body_stream_field as enforce_request_body_stream_field_impl,
     force_upstream_streaming_for_provider as force_upstream_streaming_for_provider_impl,
-    is_json_request, parse_direct_request_body as parse_direct_request_body_impl,
-    resolve_upstream_is_stream_from_endpoint_config as resolve_upstream_is_stream_from_endpoint_config_impl,
+    parse_direct_request_body as parse_direct_request_body_impl,
+    resolve_format_upstream_is_stream_for_provider as resolve_upstream_is_stream_for_provider_impl,
 };
 pub(crate) use crate::ai_serving::{
     CLAUDE_CHAT_STREAM_PLAN_KIND, CLAUDE_CHAT_SYNC_PLAN_KIND, CLAUDE_CLI_STREAM_PLAN_KIND,
@@ -20,9 +21,10 @@ pub(crate) use crate::ai_serving::{
     OPENAI_EMBEDDING_SYNC_PLAN_KIND, OPENAI_IMAGE_STREAM_PLAN_KIND, OPENAI_IMAGE_SYNC_PLAN_KIND,
     OPENAI_RERANK_SYNC_PLAN_KIND, OPENAI_RESPONSES_COMPACT_STREAM_PLAN_KIND,
     OPENAI_RESPONSES_COMPACT_SYNC_PLAN_KIND, OPENAI_RESPONSES_STREAM_PLAN_KIND,
-    OPENAI_RESPONSES_SYNC_PLAN_KIND, OPENAI_VIDEO_CANCEL_SYNC_PLAN_KIND,
-    OPENAI_VIDEO_CONTENT_PLAN_KIND, OPENAI_VIDEO_CREATE_SYNC_PLAN_KIND,
-    OPENAI_VIDEO_DELETE_SYNC_PLAN_KIND, OPENAI_VIDEO_REMIX_SYNC_PLAN_KIND,
+    OPENAI_RESPONSES_SYNC_PLAN_KIND, OPENAI_SEARCH_SYNC_PLAN_KIND,
+    OPENAI_VIDEO_CANCEL_SYNC_PLAN_KIND, OPENAI_VIDEO_CONTENT_PLAN_KIND,
+    OPENAI_VIDEO_CREATE_SYNC_PLAN_KIND, OPENAI_VIDEO_DELETE_SYNC_PLAN_KIND,
+    OPENAI_VIDEO_REMIX_SYNC_PLAN_KIND,
 };
 
 pub(crate) use aether_ai_serving::AiRequestedModelFamily as RequestedModelFamily;
@@ -54,10 +56,10 @@ pub(crate) fn resolve_upstream_is_stream_for_provider(
     client_is_stream: bool,
     hard_requires_streaming: bool,
 ) -> bool {
-    let hard_requires_streaming = hard_requires_streaming
-        || force_upstream_streaming_for_provider(provider_type, provider_api_format);
-    resolve_upstream_is_stream_from_endpoint_config_impl(
+    resolve_upstream_is_stream_for_provider_impl(
         endpoint_config,
+        provider_type,
+        provider_api_format,
         client_is_stream,
         hard_requires_streaming,
     )
@@ -178,6 +180,27 @@ mod tests {
             true,
             false,
         ));
+        assert!(!resolve_upstream_is_stream_for_provider(
+            Some(&json!({"upstream_stream_policy": "force_stream"})),
+            "codex",
+            "openai:image",
+            true,
+            true,
+        ));
+        assert!(!resolve_upstream_is_stream_for_provider(
+            Some(&json!({"upstream_stream_policy": "force_stream"})),
+            "codex",
+            "openai:responses:compact",
+            true,
+            true,
+        ));
+        assert!(!resolve_upstream_is_stream_for_provider(
+            Some(&json!({"upstream_stream_policy": "force_stream"})),
+            "custom",
+            "openai:responses:compact",
+            true,
+            true,
+        ));
     }
 
     #[test]

apps/aether-gateway/src/ai_serving/planner/decision/control_plan.rs

@@ -8,9 +8,10 @@ use crate::ai_serving::planner::common::{
     OPENAI_EMBEDDING_SYNC_PLAN_KIND, OPENAI_IMAGE_STREAM_PLAN_KIND, OPENAI_IMAGE_SYNC_PLAN_KIND,
     OPENAI_RERANK_SYNC_PLAN_KIND, OPENAI_RESPONSES_COMPACT_STREAM_PLAN_KIND,
     OPENAI_RESPONSES_COMPACT_SYNC_PLAN_KIND, OPENAI_RESPONSES_STREAM_PLAN_KIND,
-    OPENAI_RESPONSES_SYNC_PLAN_KIND, OPENAI_VIDEO_CANCEL_SYNC_PLAN_KIND,
-    OPENAI_VIDEO_CONTENT_PLAN_KIND, OPENAI_VIDEO_CREATE_SYNC_PLAN_KIND,
-    OPENAI_VIDEO_DELETE_SYNC_PLAN_KIND, OPENAI_VIDEO_REMIX_SYNC_PLAN_KIND,
+    OPENAI_RESPONSES_SYNC_PLAN_KIND, OPENAI_SEARCH_SYNC_PLAN_KIND,
+    OPENAI_VIDEO_CANCEL_SYNC_PLAN_KIND, OPENAI_VIDEO_CONTENT_PLAN_KIND,
+    OPENAI_VIDEO_CREATE_SYNC_PLAN_KIND, OPENAI_VIDEO_DELETE_SYNC_PLAN_KIND,
+    OPENAI_VIDEO_REMIX_SYNC_PLAN_KIND,
 };
 use crate::ai_serving::planner::plan_builders::{
     build_gemini_stream_plan_from_decision, build_gemini_sync_plan_from_decision,
@@ -100,7 +101,9 @@ fn build_sync_plan_payload_from_decision(
         OPENAI_RESPONSES_SYNC_PLAN_KIND => {
             build_openai_responses_sync_plan_from_decision(parts, body_json, payload, false)?
         }
-        OPENAI_IMAGE_SYNC_PLAN_KIND => build_passthrough_sync_plan_from_decision(parts, payload)?,
+        OPENAI_IMAGE_SYNC_PLAN_KIND | OPENAI_SEARCH_SYNC_PLAN_KIND => {
+            build_passthrough_sync_plan_from_decision(parts, payload)?
+        }
         OPENAI_RESPONSES_COMPACT_SYNC_PLAN_KIND => {
             build_openai_responses_sync_plan_from_decision(parts, body_json, payload, true)?
         }

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

@@ -14,8 +14,11 @@ use serde_json::{json, Value};
 use tracing::warn;
 
 use crate::ai_serving::planner::common::extract_standard_requested_model;
-use crate::ai_serving::{ExecutionRuntimeAuthContext, GatewayAuthApiKeySnapshot, PlannerAppState};
-use crate::client_session_affinity::client_session_affinity_from_request;
+use crate::ai_serving::{
+    ExecutionRuntimeAuthContext, GatewayAuthApiKeySnapshot, GatewayProviderTransportSnapshot,
+    PlannerAppState, CODEX_RESPONSES_LITE_HEADER,
+};
+use crate::client_session_affinity::client_session_affinity_from_api_request;
 use crate::clock::current_unix_secs;
 use crate::routing::{
     apply_routing_mutation_plan, build_routing_trace_seed, resolve_gateway_routing_policy,
@@ -27,12 +30,15 @@ use crate::stage_metrics::observe_gateway_stage_ms;
 use crate::{AiExecutionDecision, AppState, GatewayError};
 
 const ROUTING_GROUP_SELECTION_CACHE_TTL: Duration = Duration::from_secs(30);
+const CODEX_ACCOUNT_ID_HEADER: &str = "chatgpt-account-id";
+const CODEX_FEDRAMP_HEADER: &str = "x-openai-fedramp";
 
 #[derive(Debug, Clone)]
 pub(crate) struct ResolvedLocalDecisionAuthInput {
     pub(crate) auth_context: ExecutionRuntimeAuthContext,
     pub(crate) auth_snapshot: GatewayAuthApiKeySnapshot,
     pub(crate) required_capabilities: Option<serde_json::Value>,
+    pub(crate) model_directive_policy: crate::system_features::ModelDirectivePolicySnapshot,
 }
 
 #[derive(Debug, Clone)]
@@ -46,6 +52,7 @@ pub(crate) struct LocalRequestedModelDecisionInput {
     pub(crate) routing_policy: Option<ResolvedRoutingPolicy>,
     pub(crate) routing_trace_seed: Option<RoutingDecisionTrace>,
     pub(crate) routing_context: Option<LocalRoutingRequestContext>,
+    pub(crate) model_directive_policy: crate::system_features::ModelDirectivePolicySnapshot,
 }
 
 #[derive(Debug, Clone)]
@@ -86,14 +93,53 @@ impl LocalRequestedModelDecisionInput {
 pub(crate) fn apply_provider_request_routing_policy_to_decision(
     input: &LocalRequestedModelDecisionInput,
     decision: &mut AiExecutionDecision,
+    transport: Option<&GatewayProviderTransportSnapshot>,
 ) -> Result<(), GatewayError> {
+    let provider_api_format = decision
+        .provider_api_format
+        .clone()
+        .or_else(|| {
+            input
+                .routing_context
+                .as_ref()
+                .map(|context| context.client_api_format.clone())
+        })
+        .unwrap_or_default();
+    let provider_type = decision.provider_type.clone().unwrap_or_default();
+    let terminal_provider_model = decision
+        .provider_request_body
+        .as_ref()
+        .and_then(|body| body.get("model"))
+        .and_then(Value::as_str)
+        .or(decision.mapped_model.as_deref())
+        .or(decision.model_name.as_deref())
+        .unwrap_or(input.requested_model.as_str());
+    let model_capabilities = transport.and_then(|transport| {
+        crate::ai_serving::codex_model_capabilities_for_transport(
+            transport,
+            provider_api_format.as_str(),
+            terminal_provider_model,
+            input.requested_model.as_str(),
+        )
+    });
+    crate::ai_serving::apply_codex_openai_responses_lite_header_for_request_body_with_capabilities(
+        &mut decision.provider_request_headers,
+        decision.provider_request_body.as_ref(),
+        provider_type.as_str(),
+        provider_api_format.as_str(),
+        terminal_provider_model,
+        input.requested_model.as_str(),
+        model_capabilities.as_ref(),
+    );
+
     let Some(context) = input.routing_context.as_ref() else {
         return Ok(());
     };
-    let provider_api_format = decision
-        .provider_api_format
-        .as_deref()
-        .unwrap_or(context.client_api_format.as_str());
+    let provider_body_rules = decision
+        .report_context
+        .as_ref()
+        .and_then(|context| context.get("body_rules"))
+        .cloned();
     let resolved_model = decision
         .mapped_model
         .as_deref()
@@ -104,6 +150,21 @@ pub(crate) fn apply_provider_request_routing_policy_to_decision(
         .clone()
         .unwrap_or(serde_json::Value::Null);
     let mut provider_headers = btree_headers_to_header_map(&decision.provider_request_headers)?;
+    let mut protected_codex_header_names = vec![CODEX_ACCOUNT_ID_HEADER, CODEX_FEDRAMP_HEADER];
+    if provider_type.eq_ignore_ascii_case("codex")
+        && crate::ai_serving::is_openai_responses_family_format(provider_api_format.as_str())
+    {
+        protected_codex_header_names.extend([
+            "x-client-request-id",
+            "accept",
+            "content-encoding",
+            CODEX_RESPONSES_LITE_HEADER,
+        ]);
+    }
+    let protected_codex_headers = protected_codex_header_names
+        .into_iter()
+        .map(|name| (name, provider_headers.get(name).cloned()))
+        .collect::<Vec<_>>();
     let provider_headers_json = headers_to_routing_value(&provider_headers);
     let policy = resolve_gateway_routing_policy(GatewayRoutingPolicyInput {
         group_id: context.group_id.as_deref(),
@@ -112,7 +173,7 @@ pub(crate) fn apply_provider_request_routing_policy_to_decision(
         selection_source: context.selection_source.as_str(),
         requested_model: input.requested_model.as_str(),
         resolved_model,
-        api_format: provider_api_format,
+        api_format: provider_api_format.as_str(),
         user_id: Some(input.auth_context.user_id.as_str()),
         api_key_id: Some(input.auth_context.api_key_id.as_str()),
         headers: &provider_headers_json,
@@ -134,6 +195,81 @@ pub(crate) fn apply_provider_request_routing_policy_to_decision(
         &mut provider_headers,
         &policy.mutation_plan,
     )?;
+    for (name, value) in protected_codex_headers {
+        provider_headers.remove(name);
+        if let Some(value) = value {
+            provider_headers.insert(HeaderName::from_static(name), value);
+        }
+    }
+    if original_provider_request_body.is_some() {
+        let provider_model = provider_request_body
+            .get("model")
+            .and_then(Value::as_str)
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+            .or(decision.mapped_model.as_deref())
+            .or(decision.model_name.as_deref())
+            .unwrap_or(input.requested_model.as_str())
+            .to_string();
+        let model_capabilities = transport.and_then(|transport| {
+            crate::ai_serving::codex_model_capabilities_for_transport(
+                transport,
+                provider_api_format.as_str(),
+                provider_model.as_str(),
+                input.requested_model.as_str(),
+            )
+        });
+        crate::ai_serving::finalize_openai_provider_request_with_codex_model_capabilities(
+            &mut provider_request_body,
+            crate::ai_serving::OpenAiProviderRequestFinalization {
+                source_api_format: context.client_api_format.as_str(),
+                provider_api_format: provider_api_format.as_str(),
+                provider_type: provider_type.as_str(),
+                provider_model: provider_model.as_str(),
+                source_model: input.requested_model.as_str(),
+                body_rules: provider_body_rules.as_ref(),
+                upstream_is_stream: decision.upstream_is_stream,
+                require_body_stream_field: original_provider_request_body
+                    .as_ref()
+                    .is_some_and(|body| body.get("stream").is_some()),
+            },
+            model_capabilities.as_ref(),
+        )
+        .map_err(|violation| GatewayError::Client {
+            status: StatusCode::BAD_REQUEST,
+            message: format!("routing provider_request violates provider contract: {violation:?}"),
+        })?;
+    }
+    let provider_model = provider_request_body
+        .get("model")
+        .and_then(Value::as_str)
+        .or(decision.mapped_model.as_deref())
+        .or(decision.model_name.as_deref())
+        .unwrap_or(input.requested_model.as_str());
+    let mut provider_request_headers = header_map_to_btree_headers(&provider_headers);
+    let model_capabilities = transport.and_then(|transport| {
+        crate::ai_serving::codex_model_capabilities_for_transport(
+            transport,
+            provider_api_format.as_str(),
+            provider_model,
+            input.requested_model.as_str(),
+        )
+    });
+    crate::ai_serving::apply_codex_openai_responses_lite_header_for_request_body_with_capabilities(
+        &mut provider_request_headers,
+        Some(&provider_request_body),
+        provider_type.as_str(),
+        provider_api_format.as_str(),
+        provider_model,
+        input.requested_model.as_str(),
+        model_capabilities.as_ref(),
+    );
+    crate::ai_serving::apply_codex_openai_compact_terminal_headers(
+        &mut provider_request_headers,
+        provider_type.as_str(),
+        provider_api_format.as_str(),
+    );
+    provider_headers = btree_headers_to_header_map(&provider_request_headers)?;
     decision.provider_request_headers = header_map_to_btree_headers(&provider_headers);
     if original_provider_request_body.is_some() {
         decision.provider_request_body = Some(provider_request_body);
@@ -145,6 +281,8 @@ pub(crate) fn apply_provider_request_routing_policy_to_decision(
 struct GatewayAuthenticatedDecisionInputPort<'a> {
     state: PlannerAppState<'a>,
     now_unix_secs: u64,
+    model_directive_policy: &'a crate::system_features::ModelDirectivePolicySnapshot,
+    model_directive_base_model: Option<String>,
 }
 
 #[async_trait]
@@ -181,6 +319,7 @@ impl AiAuthenticatedDecisionInputPort for GatewayAuthenticatedDecisionInputPort<
                 &auth_context.api_key_id,
                 requested_model,
                 explicit_required_capabilities,
+                self.model_directive_base_model.as_deref(),
             )
             .await)
     }
@@ -195,6 +334,7 @@ impl AiAuthenticatedDecisionInputPort for GatewayAuthenticatedDecisionInputPort<
             auth_context,
             auth_snapshot,
             required_capabilities,
+            model_directive_policy: self.model_directive_policy.clone(),
         }
     }
 }
@@ -213,6 +353,7 @@ pub(crate) fn build_local_requested_model_decision_input(
         routing_policy: None,
         routing_trace_seed: None,
         routing_context: None,
+        model_directive_policy: resolved_input.model_directive_policy,
     }
 }
 
@@ -310,8 +451,11 @@ pub(crate) async fn attach_routing_policy_to_local_requested_model_input(
 
     let Some((group_id, group_version, group_config_json, selection_source)) = selected_group
     else {
-        input.client_session_affinity =
-            client_session_affinity_from_request(&parts.headers, Some(body_json));
+        input.client_session_affinity = client_session_affinity_from_api_request(
+            client_api_format,
+            &parts.headers,
+            Some(body_json),
+        );
         input.routing_policy = None;
         input.routing_trace_seed = None;
         input.routing_context = None;
@@ -373,19 +517,26 @@ pub(crate) async fn attach_routing_policy_to_local_requested_model_input(
         }
     }
     if requested_model_changed {
+        let model_directive_resolution = input
+            .model_directive_policy
+            .resolve_reasoning(client_api_format, Some(input.requested_model.as_str()));
         input.required_capabilities = PlannerAppState::new(state)
             .resolve_request_candidate_required_capabilities(
                 &input.auth_context.user_id,
                 &input.auth_context.api_key_id,
                 Some(input.requested_model.as_str()),
                 input.required_capabilities.as_ref(),
+                model_directive_resolution.base_model(),
             )
             .await;
     }
 
     let effective_headers_json = headers_to_routing_value(&effective_headers);
-    input.client_session_affinity =
-        client_session_affinity_from_request(&effective_headers, Some(&effective_body_json));
+    input.client_session_affinity = client_session_affinity_from_api_request(
+        client_api_format,
+        &effective_headers,
+        Some(&effective_body_json),
+    );
     let final_policy_resolve_started_at = std::time::Instant::now();
     let mut final_policy = resolve_gateway_routing_policy(GatewayRoutingPolicyInput {
         group_id: group_id.as_deref(),
@@ -452,8 +603,11 @@ fn try_attach_static_default_routing_policy_to_input(
         static_policy_resolve_started_at.elapsed().as_millis() as u64,
     );
 
-    input.client_session_affinity =
-        client_session_affinity_from_request(&parts.headers, Some(body_json));
+    input.client_session_affinity = client_session_affinity_from_api_request(
+        client_api_format,
+        &parts.headers,
+        Some(body_json),
+    );
     input.routing_trace_seed = Some(build_routing_trace_seed(&policy, client_api_format));
     input.routing_policy = Some(policy);
     input.routing_context = None;
@@ -475,11 +629,22 @@ pub(crate) async fn resolve_local_authenticated_decision_input(
     state: &AppState,
     auth_context: ExecutionRuntimeAuthContext,
     requested_model: Option<&str>,
+    requested_model_api_format: Option<&str>,
     explicit_required_capabilities: Option<&serde_json::Value>,
+    model_directive_policy: &crate::system_features::ModelDirectivePolicySnapshot,
 ) -> Result<Option<ResolvedLocalDecisionAuthInput>, GatewayError> {
+    let model_directive_base_model = match (requested_model, requested_model_api_format) {
+        (Some(model), Some(api_format)) => model_directive_policy
+            .resolve_reasoning(api_format, Some(model))
+            .base_model()
+            .map(str::to_owned),
+        _ => None,
+    };
     let port = GatewayAuthenticatedDecisionInputPort {
         state: PlannerAppState::new(state),
         now_unix_secs: current_unix_secs(),
+        model_directive_policy,
+        model_directive_base_model,
     };
 
     run_ai_authenticated_decision_input(
@@ -730,6 +895,10 @@ fn ensure_report_context_routing_trace(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use aether_provider_transport::snapshot::{
+        GatewayProviderTransportEndpoint, GatewayProviderTransportKey,
+        GatewayProviderTransportProvider,
+    };
 
     fn sample_auth_context() -> ExecutionRuntimeAuthContext {
         ExecutionRuntimeAuthContext {
@@ -782,6 +951,7 @@ mod tests {
             client_session_affinity: None,
             routing_policy: None,
             routing_trace_seed: None,
+            model_directive_policy: Default::default(),
             routing_context: Some(LocalRoutingRequestContext {
                 group_id: Some("group-1".to_string()),
                 group_version: Some(3),
@@ -830,6 +1000,7 @@ mod tests {
             request_id: Some("trace-1".to_string()),
             candidate_id: Some("candidate-1".to_string()),
             provider_name: Some("provider".to_string()),
+            provider_type: Some("openai".to_string()),
             provider_id: Some("provider-1".to_string()),
             endpoint_id: Some("endpoint-1".to_string()),
             key_id: Some("key-1".to_string()),
@@ -869,9 +1040,80 @@ mod tests {
         }
     }
 
-    fn set_provider_request_rules(input: &mut LocalRequestedModelDecisionInput, actions: Value) {
+    fn sample_codex_transport_with_card() -> GatewayProviderTransportSnapshot {
+        let card = json!({
+            "id": "gpt-future-agent",
+            "slug": "gpt-future-agent",
+            "use_responses_lite": true,
+            "supports_reasoning_summary_parameter": true,
+            "default_reasoning_level": "low",
+            "default_reasoning_summary": "none",
+            "supported_reasoning_levels": [{"effort": "low"}, {"effort": "high"}]
+        });
+        GatewayProviderTransportSnapshot {
+            provider: GatewayProviderTransportProvider {
+                id: "provider-codex".to_string(),
+                name: "Codex".to_string(),
+                provider_type: "codex".to_string(),
+                website: None,
+                is_active: true,
+                keep_priority_on_conversion: false,
+                enable_format_conversion: true,
+                concurrent_limit: None,
+                max_retries: None,
+                proxy: None,
+                request_timeout_secs: None,
+                stream_first_byte_timeout_secs: None,
+                config: None,
+            },
+            endpoint: GatewayProviderTransportEndpoint {
+                id: "endpoint-codex".to_string(),
+                provider_id: "provider-codex".to_string(),
+                api_format: "openai:responses:compact".to_string(),
+                api_family: Some("openai".to_string()),
+                endpoint_kind: Some("compact".to_string()),
+                is_active: true,
+                base_url: "https://chatgpt.com/backend-api/codex".to_string(),
+                header_rules: None,
+                body_rules: None,
+                max_retries: None,
+                custom_path: None,
+                config: None,
+                format_acceptance_config: None,
+                proxy: None,
+            },
+            key: GatewayProviderTransportKey {
+                id: "key-codex".to_string(),
+                provider_id: "provider-codex".to_string(),
+                name: "Codex key".to_string(),
+                auth_type: "oauth".to_string(),
+                is_active: true,
+                api_formats: Some(vec!["openai:responses:compact".to_string()]),
+                auth_type_by_format: None,
+                allow_auth_channel_mismatch_formats: None,
+                allowed_models: Some(vec!["gpt-future-agent".to_string()]),
+                capabilities: None,
+                rate_multipliers: None,
+                global_priority_by_format: None,
+                expires_at_unix_secs: None,
+                proxy: None,
+                fingerprint: None,
+                upstream_metadata: Some(crate::ai_serving::build_codex_model_catalog_metadata(&[
+                    card,
+                ])),
+                decrypted_api_key: "access-token".to_string(),
+                decrypted_auth_config: None,
+            },
+        }
+    }
+
+    fn set_provider_request_rules(
+        input: &mut LocalRequestedModelDecisionInput,
+        allowed_models: &[&str],
+        actions: Value,
+    ) {
         let config = json!({
-            "allowed_models": ["gpt-5"],
+            "allowed_models": allowed_models,
             "rules": [{
                 "id": "provider-patch",
                 "priority": 1,
@@ -904,6 +1146,7 @@ mod tests {
             client_session_affinity: None,
             routing_policy: None,
             routing_trace_seed: None,
+            model_directive_policy: Default::default(),
             routing_context: Some(LocalRoutingRequestContext {
                 group_id: Some("stale".to_string()),
                 group_version: Some(1),
@@ -971,6 +1214,7 @@ mod tests {
             routing_policy: None,
             routing_trace_seed: None,
             routing_context: None,
+            model_directive_policy: Default::default(),
         };
         let group_config_json = json!({
             "rules": [{
@@ -1006,7 +1250,7 @@ mod tests {
         let input = sample_decision_input();
         let mut decision = sample_decision();
 
-        apply_provider_request_routing_policy_to_decision(&input, &mut decision)
+        apply_provider_request_routing_policy_to_decision(&input, &mut decision, None)
             .expect("provider routing mutation should apply");
 
         assert_eq!(
@@ -1035,6 +1279,179 @@ mod tests {
         );
     }
 
+    #[test]
+    fn codex_compact_contract_is_terminal_after_routing_mutations() {
+        let mut input = sample_decision_input();
+        input
+            .routing_context
+            .as_mut()
+            .expect("routing context")
+            .client_api_format = "openai:responses:compact".to_string();
+        set_provider_request_rules(
+            &mut input,
+            &["gpt-5"],
+            json!([
+                {
+                    "type": "json_patch_body",
+                    "patch": [
+                        {"op": "add", "path": "/store", "value": true},
+                        {"op": "add", "path": "/top_logprobs", "value": 5},
+                        {"op": "add", "path": "/custom_extension", "value": true},
+                        {"op": "replace", "path": "/input", "value": "routed compact input"},
+                        {"op": "replace", "path": "/tools", "value": [{
+                            "type": "function",
+                            "name": "lookup",
+                            "cache_control": {"type": "ephemeral"}
+                        }]}
+                    ]
+                },
+                {
+                    "type": "patch_headers",
+                    "patch": [
+                        {"op": "set", "name": "chatgpt-account-id", "value": "spoofed"},
+                        {"op": "set", "name": "x-openai-fedramp", "value": "false"},
+                        {"op": "set", "name": "x-client-request-id", "value": "spoofed"},
+                        {"op": "set", "name": "accept", "value": "text/event-stream"},
+                        {"op": "set", "name": "content-encoding", "value": "zstd"}
+                    ]
+                }
+            ]),
+        );
+        let mut decision = sample_decision();
+        decision.provider_type = Some("codex".to_string());
+        decision.provider_api_format = Some("openai:responses:compact".to_string());
+        decision.client_api_format = Some("openai:responses:compact".to_string());
+        decision.provider_request_body = Some(json!({
+            "model": "gpt-5",
+            "input": [],
+            "tools": [{"type": "function", "name": "lookup"}]
+        }));
+        decision
+            .provider_request_headers
+            .insert(CODEX_ACCOUNT_ID_HEADER.to_string(), "account-1".to_string());
+        decision
+            .provider_request_headers
+            .insert(CODEX_FEDRAMP_HEADER.to_string(), "true".to_string());
+
+        apply_provider_request_routing_policy_to_decision(&input, &mut decision, None)
+            .expect("terminal contract should accept the projected request");
+
+        let body = decision.provider_request_body.as_ref().expect("body");
+        assert_eq!(body["parallel_tool_calls"], false);
+        assert_eq!(body["input"][0]["type"], "message");
+        assert_eq!(
+            body["input"][0]["content"][0]["text"],
+            "routed compact input"
+        );
+        assert!(body["tools"][0].get("cache_control").is_none());
+        for field in ["store", "top_logprobs", "custom_extension"] {
+            assert!(
+                body.get(field).is_none(),
+                "unexpected Compact field: {field}"
+            );
+        }
+        assert_eq!(
+            decision
+                .provider_request_headers
+                .get(CODEX_ACCOUNT_ID_HEADER),
+            Some(&"account-1".to_string())
+        );
+        assert_eq!(
+            decision.provider_request_headers.get(CODEX_FEDRAMP_HEADER),
+            Some(&"true".to_string())
+        );
+        for header in ["x-client-request-id", "accept", "content-encoding"] {
+            assert!(
+                !decision.provider_request_headers.contains_key(header),
+                "unexpected Compact header: {header}"
+            );
+        }
+    }
+
+    #[test]
+    fn codex_responses_lite_contract_is_terminal_after_routing_mutations() {
+        let mut input = sample_decision_input();
+        input.requested_model = "gpt-future-agent".to_string();
+        input
+            .routing_context
+            .as_mut()
+            .expect("routing context")
+            .client_api_format = "openai:responses:compact".to_string();
+        set_provider_request_rules(
+            &mut input,
+            &["gpt-future-agent"],
+            json!([
+                {
+                    "type": "json_patch_body",
+                    "patch": [
+                        {"op": "replace", "path": "/input", "value": "routed compact input"},
+                        {"op": "add", "path": "/instructions", "value": "Routed instructions"},
+                        {"op": "replace", "path": "/tools", "value": [{
+                            "type": "function",
+                            "name": "lookup",
+                            "parameters": {},
+                            "cache_control": {"type": "ephemeral"}
+                        }]},
+                        {"op": "add", "path": "/parallel_tool_calls", "value": true},
+                        {"op": "add", "path": "/reasoning", "value": {
+                            "effort": "high",
+                            "context": "current_turn"
+                        }}
+                    ]
+                },
+                {
+                    "type": "patch_headers",
+                    "patch": [{
+                        "op": "set",
+                        "name": "x-openai-internal-codex-responses-lite",
+                        "value": "false"
+                    }]
+                }
+            ]),
+        );
+        let mut decision = sample_decision();
+        decision.provider_type = Some("codex".to_string());
+        decision.provider_api_format = Some("openai:responses:compact".to_string());
+        decision.client_api_format = Some("openai:responses:compact".to_string());
+        decision.mapped_model = Some("gpt-future-agent".to_string());
+        decision.provider_request_body = Some(json!({
+            "model": "gpt-future-agent",
+            "input": [],
+            "tools": []
+        }));
+        let transport = sample_codex_transport_with_card();
+
+        apply_provider_request_routing_policy_to_decision(&input, &mut decision, Some(&transport))
+            .expect("terminal Lite contract should accept the projected request");
+
+        let body = decision.provider_request_body.as_ref().expect("body");
+        assert_eq!(body["input"][0]["type"], "additional_tools");
+        assert_eq!(body["input"][0]["tools"][0]["name"], "lookup");
+        assert!(body["input"][0]["tools"][0].get("cache_control").is_none());
+        assert_eq!(body["input"][1]["role"], "developer");
+        assert_eq!(
+            body["input"][1]["content"][0]["text"],
+            "Routed instructions"
+        );
+        assert_eq!(body["input"][2]["role"], "user");
+        assert_eq!(
+            body["input"][2]["content"][0]["text"],
+            "routed compact input"
+        );
+        assert!(body.get("tools").is_none());
+        assert!(body.get("instructions").is_none());
+        assert_eq!(body["parallel_tool_calls"], false);
+        assert_eq!(body["reasoning"]["effort"], "high");
+        assert_eq!(body["reasoning"]["context"], "all_turns");
+        assert_eq!(
+            decision
+                .provider_request_headers
+                .get(CODEX_RESPONSES_LITE_HEADER)
+                .map(String::as_str),
+            Some("true")
+        );
+    }
+
     #[test]
     fn provider_request_routing_policy_rejects_body_patch_without_json_body() {
         let input = sample_decision_input();
@@ -1042,7 +1459,7 @@ mod tests {
         decision.provider_request_body = None;
         decision.provider_request_body_base64 = Some("AA==".to_string());
 
-        let error = apply_provider_request_routing_policy_to_decision(&input, &mut decision)
+        let error = apply_provider_request_routing_policy_to_decision(&input, &mut decision, None)
             .expect_err("provider body patch should reject binary upstream bodies");
 
         match error {
@@ -1067,6 +1484,7 @@ mod tests {
         let mut input = sample_decision_input();
         set_provider_request_rules(
             &mut input,
+            &["gpt-5"],
             json!([{
                 "type": "patch_headers",
                 "patch": [{
@@ -1080,7 +1498,7 @@ mod tests {
         decision.provider_request_body = None;
         decision.provider_request_body_base64 = Some("AA==".to_string());
 
-        apply_provider_request_routing_policy_to_decision(&input, &mut decision)
+        apply_provider_request_routing_policy_to_decision(&input, &mut decision, None)
             .expect("header-only provider routing mutation should apply without JSON body");
 
         assert_eq!(decision.provider_request_body, None);
@@ -1112,7 +1530,7 @@ mod tests {
             "priority_slot": 3
         }));
 
-        apply_provider_request_routing_policy_to_decision(&input, &mut decision)
+        apply_provider_request_routing_policy_to_decision(&input, &mut decision, None)
             .expect("provider routing mutation should seed pool trace");
 
         let routing_trace = &decision.report_context.as_ref().unwrap()["routing_trace"];

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

@@ -34,6 +34,7 @@ pub(crate) use self::candidate_resolution::{
     candidate_auth_channel_skip_reason, read_candidate_transport_snapshot,
     EligibleLocalExecutionCandidate, LocalExecutionCandidateKind, SkippedLocalExecutionCandidate,
 };
+pub(crate) use self::common::resolve_upstream_is_stream_for_provider;
 pub(crate) use self::passthrough::{
     build_local_same_format_stream_attempt_source, build_local_same_format_stream_plan_and_reports,
     build_local_same_format_sync_attempt_source, build_local_same_format_sync_plan_and_reports,
@@ -48,7 +49,7 @@ pub(crate) use self::plan_builders::{
 pub(crate) use self::pool_scores::{
     build_provider_key_pool_score_upsert, provider_key_pool_score_id, provider_key_pool_score_scope,
 };
-pub(crate) use self::request_gzip::resolve_transport_request_gzip_policy;
+pub(crate) use self::request_gzip::resolve_transport_request_encoding_policy;
 pub(crate) use self::route::is_matching_stream_request as planner_is_matching_stream_request;
 pub(crate) use self::runtime_miss::{
     apply_local_runtime_candidate_terminal_reason, record_local_runtime_candidate_skip_reason,
@@ -79,7 +80,8 @@ pub(crate) use self::standard::{
     build_local_stream_plan_and_reports as build_standard_family_stream_plan_and_reports,
     build_local_sync_attempt_source as build_standard_family_sync_attempt_source,
     build_local_sync_plan_and_reports as build_standard_family_sync_plan_and_reports,
-    set_local_openai_chat_execution_exhausted_diagnostic,
+    codex_model_capabilities_for_transport, set_local_openai_chat_execution_exhausted_diagnostic,
+    validate_final_openai_provider_request,
 };
 pub(crate) use self::state::{
     GatewayAuthApiKeySnapshot, GatewayProviderTransportSnapshot, LocalResolvedOAuthRequestAuth,

apps/aether-gateway/src/ai_serving/planner/passthrough/plan_builders.rs

@@ -71,6 +71,7 @@ pub(crate) fn build_passthrough_stream_plan_from_decision(
         .content_type
         .take()
         .or_else(|| provider_request_headers.get("content-type").cloned());
+    let stream = payload.upstream_is_stream;
     let plan = build_ai_execution_plan_from_decision(
         &mut payload,
         AiExecutionPlanFromDecisionParts {
@@ -84,7 +85,7 @@ pub(crate) fn build_passthrough_stream_plan_from_decision(
                 body_bytes_b64: None,
                 body_ref: None,
             },
-            stream: true,
+            stream,
         },
     );
 

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

@@ -24,7 +24,7 @@ use crate::ai_serving::{
     ai_local_execution_contract_for_formats, extract_pool_sticky_session_token,
     resolve_local_decision_execution_runtime_auth_context, GatewayControlDecision, PlannerAppState,
 };
-use crate::client_session_affinity::client_session_affinity_from_parts;
+use crate::client_session_affinity::client_session_affinity_from_api_request;
 use crate::clock::current_unix_secs;
 use crate::{AppState, GatewayError};
 
@@ -60,7 +60,9 @@ pub(crate) async fn resolve_local_same_format_provider_decision_input(
         state,
         auth_context,
         Some(requested_model.as_str()),
+        decision.auth_endpoint_signature.as_deref(),
         None,
+        &decision.model_directive_policy,
     )
     .await
     {
@@ -79,7 +81,11 @@ pub(crate) async fn resolve_local_same_format_provider_decision_input(
 
     let mut input = build_local_requested_model_decision_input(resolved_input, requested_model);
     input.request_auth_channel = decision.request_auth_channel.clone();
-    input.client_session_affinity = client_session_affinity_from_parts(parts, Some(body_json));
+    input.client_session_affinity = client_session_affinity_from_api_request(
+        spec_metadata.api_format,
+        &parts.headers,
+        Some(body_json),
+    );
     if let Err(err) = attach_routing_policy_to_local_requested_model_input(
         state,
         parts,
@@ -115,15 +121,22 @@ pub(crate) async fn materialize_local_same_format_provider_candidate_attempts(
         input.required_capabilities.as_ref(),
         LocalCandidatePersistencePolicyKind::SameFormatProviderDecision,
     );
+    let model_directive_resolution = input
+        .model_directive_policy
+        .resolve_reasoning(spec_metadata.api_format, Some(&input.requested_model));
+    let routing_model = model_directive_resolution
+        .base_model()
+        .unwrap_or(&input.requested_model);
     let (candidates, preselection_skipped) = planner_state
         .list_selectable_candidates_with_skip_reasons(
             spec_metadata.api_format,
-            &input.requested_model,
+            routing_model,
             spec_metadata.require_streaming,
             input.required_capabilities.as_ref(),
             Some(&input.auth_snapshot),
             input.client_session_affinity.as_ref(),
             current_unix_secs(),
+            false,
         )
         .await?;
     let outcome = materialize_local_execution_candidates_with_serving(
@@ -212,15 +225,22 @@ pub(crate) async fn build_local_same_format_provider_candidate_attempt_source<'a
         input.required_capabilities.as_ref(),
         LocalCandidatePersistencePolicyKind::SameFormatProviderDecision,
     );
+    let model_directive_resolution = input
+        .model_directive_policy
+        .resolve_reasoning(spec_metadata.api_format, Some(&input.requested_model));
+    let routing_model = model_directive_resolution
+        .base_model()
+        .unwrap_or(&input.requested_model);
     let (candidates, preselection_skipped) = planner_state
         .list_selectable_candidates_with_skip_reasons(
             spec_metadata.api_format,
-            &input.requested_model,
+            routing_model,
             spec_metadata.require_streaming,
             input.required_capabilities.as_ref(),
             Some(&input.auth_snapshot),
             input.client_session_affinity.as_ref(),
             current_unix_secs(),
+            false,
         )
         .await?;
 

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

@@ -17,7 +17,7 @@ use crate::ai_serving::planner::report_context::{
 use crate::ai_serving::planner::spec_metadata::local_same_format_provider_spec_metadata;
 use crate::ai_serving::planner::CandidateFailureDiagnostic;
 use crate::ai_serving::planner::{
-    build_ai_execution_decision_response, resolve_transport_request_gzip_policy,
+    build_ai_execution_decision_response, resolve_transport_request_encoding_policy,
     AiExecutionDecisionResponseParts,
 };
 use crate::ai_serving::transport::{
@@ -184,7 +184,7 @@ pub(crate) async fn maybe_build_local_same_format_provider_decision_payload_for_
         compatibility_edits: _,
         request_redacted: _,
     } = resolved;
-    let request_gzip = resolve_transport_request_gzip_policy(&transport);
+    let request_encoding = resolve_transport_request_encoding_policy(&transport);
 
     let mut decision = build_ai_execution_decision_response(AiExecutionDecisionResponseParts {
         decision_is_stream: spec_metadata.require_streaming,
@@ -194,6 +194,7 @@ pub(crate) async fn maybe_build_local_same_format_provider_decision_payload_for_
         request_id: trace_id.to_string(),
         candidate_id: candidate_id.to_string(),
         provider_name: transport.provider.name.clone(),
+        provider_type: transport.provider.provider_type.clone(),
         provider_id: candidate.provider_id.clone(),
         endpoint_id: candidate.endpoint_id.clone(),
         key_id: candidate.key_id.clone(),
@@ -211,8 +212,8 @@ pub(crate) async fn maybe_build_local_same_format_provider_decision_payload_for_
         provider_request_body: Some(provider_request_body),
         provider_request_body_base64: None,
         content_type: Some("application/json".to_string()),
-        content_encoding: None,
-        request_gzip,
+        content_encoding: request_encoding.content_encoding,
+        request_gzip: request_encoding.request_gzip,
         proxy,
         transport_profile,
         timeouts: resolve_transport_execution_timeouts(&transport),
@@ -221,7 +222,11 @@ pub(crate) async fn maybe_build_local_same_format_provider_decision_payload_for_
         report_context: Some(report_context),
         auth_context: input.auth_context.clone(),
     });
-    apply_provider_request_routing_policy_to_decision(input, &mut decision)?;
+    apply_provider_request_routing_policy_to_decision(
+        input,
+        &mut decision,
+        Some(transport.as_ref()),
+    )?;
     Ok(Some(decision))
 }
 

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

@@ -40,7 +40,9 @@ use super::{
     LocalSameFormatProviderCandidateAttempt, LocalSameFormatProviderDecisionInput,
     LocalSameFormatProviderSpec,
 };
-use crate::ai_serving::planner::standard::same_format_provider_request_body_failure_extra_data;
+use crate::ai_serving::planner::standard::{
+    codex_model_capabilities_for_transport, same_format_provider_request_body_failure_extra_data,
+};
 
 pub(crate) fn resolve_same_format_provider_transport_unsupported_reason_for_trace(
     transport: &GatewayProviderTransportSnapshot,
@@ -51,6 +53,7 @@ pub(crate) fn resolve_same_format_provider_transport_unsupported_reason_for_trac
             "openai:chat" => "openai:chat",
             "openai:responses" => "openai:responses",
             "openai:responses:compact" => "openai:responses:compact",
+            "openai:search" => "openai:search",
             "openai:embedding" => "openai:embedding",
             "openai:rerank" => "openai:rerank",
             "claude:messages" => "claude:messages",
@@ -137,13 +140,26 @@ pub(crate) async fn resolve_local_same_format_provider_candidate_payload_parts(
     else {
         return Ok(None);
     };
-    let enable_model_directives =
-        crate::system_features::reasoning_model_directive_enabled_for_api_format_and_model(
-            state,
-            spec.api_format,
-            Some(&input.requested_model),
-        )
-        .await;
+    let model_directive_resolution = input
+        .model_directive_policy
+        .resolve_reasoning(spec.api_format, Some(&input.requested_model));
+    let model_directive_mapping =
+        match model_directive_resolution.mapping_patch_for_mapped_model(&prepared.mapped_model) {
+            Ok(mapping) => mapping,
+            Err(skip_reason) => {
+                mark_skipped_local_same_format_provider_candidate(
+                    state,
+                    input,
+                    trace_id,
+                    candidate,
+                    attempt.candidate_index,
+                    &attempt.candidate_id,
+                    skip_reason,
+                )
+                .await;
+                return Ok(None);
+            }
+        };
     let effective_headers = input.effective_headers(&parts.headers);
     let redaction = resolve_provider_chat_pii_redaction(
         state,
@@ -169,7 +185,7 @@ pub(crate) async fn resolve_local_same_format_provider_candidate_payload_parts(
             prepared.force_body_stream_field,
             prepared.kiro_auth.as_ref(),
             prepared.is_claude_code,
-            enable_model_directives,
+            false,
         )
     else {
         mark_skipped_local_same_format_provider_candidate_with_extra_data(
@@ -196,18 +212,11 @@ pub(crate) async fn resolve_local_same_format_provider_candidate_payload_parts(
     };
     let mut base_provider_request_body = base_provider_request.body;
     let mut compatibility_edits = base_provider_request.compatibility_edits;
-    if let Some(mapping) =
-        crate::system_features::reasoning_model_directive_mapping_for_api_format_and_model(
-            state,
-            spec.api_format,
-            Some(&input.requested_model),
-        )
-        .await
-    {
+    if let Some(mapping) = model_directive_mapping.as_ref() {
         let before_mapping = base_provider_request_body.clone();
         crate::ai_serving::apply_model_directive_mapping_patch(
             &mut base_provider_request_body,
-            &mapping,
+            mapping,
         );
         if before_mapping != base_provider_request_body {
             compatibility_edits.push(SameFormatProviderCompatibilityEdit {
@@ -230,6 +239,48 @@ pub(crate) async fn resolve_local_same_format_provider_candidate_payload_parts(
         }
     }
 
+    let source_model = body_json
+        .get("model")
+        .and_then(Value::as_str)
+        .unwrap_or(input.requested_model.as_str());
+    let codex_model_capabilities = codex_model_capabilities_for_transport(
+        &transport,
+        prepared.provider_api_format.as_str(),
+        prepared.mapped_model.as_str(),
+        source_model,
+    );
+    if crate::ai_serving::finalize_openai_provider_request_with_codex_model_capabilities(
+        &mut base_provider_request_body,
+        crate::ai_serving::OpenAiProviderRequestFinalization {
+            source_api_format: spec.api_format,
+            provider_api_format: prepared.provider_api_format.as_str(),
+            provider_type: transport.provider.provider_type.as_str(),
+            provider_model: prepared.mapped_model.as_str(),
+            source_model,
+            body_rules: transport.endpoint.body_rules.as_ref(),
+            upstream_is_stream: prepared.upstream_is_stream,
+            require_body_stream_field: request_requires_body_stream_field(
+                body_json,
+                prepared.force_body_stream_field,
+            ),
+        },
+        codex_model_capabilities.as_ref(),
+    )
+    .is_err()
+    {
+        mark_skipped_local_same_format_provider_candidate(
+            state,
+            input,
+            trace_id,
+            candidate,
+            attempt.candidate_index,
+            &attempt.candidate_id,
+            "provider_request_body_missing",
+        )
+        .await;
+        return Ok(None);
+    }
+
     let antigravity_auth = if prepared.is_antigravity {
         let mut antigravity_support = classify_local_antigravity_request_support(
             &transport,
@@ -467,6 +518,28 @@ pub(crate) async fn resolve_local_same_format_provider_candidate_payload_parts(
         .await;
         return Ok(None);
     };
+    crate::ai_serving::apply_codex_openai_special_headers(
+        &mut provider_request_headers,
+        &provider_request_body,
+        effective_headers,
+        transport.provider.provider_type.as_str(),
+        prepared.provider_api_format.as_str(),
+        Some(trace_id),
+        transport.key.decrypted_auth_config.as_deref(),
+    );
+    let provider_model = provider_request_body
+        .get("model")
+        .and_then(Value::as_str)
+        .unwrap_or(prepared.mapped_model.as_str());
+    crate::ai_serving::apply_codex_openai_responses_lite_header_for_request_body_with_capabilities(
+        &mut provider_request_headers,
+        Some(&provider_request_body),
+        transport.provider.provider_type.as_str(),
+        prepared.provider_api_format.as_str(),
+        provider_model,
+        source_model,
+        codex_model_capabilities.as_ref(),
+    );
     request_identity_response_encoding_when_redacted(
         &mut provider_request_headers,
         redaction.redacted,

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

@@ -1,23 +1,50 @@
 use aether_ai_serving::AiRequestGzipPolicy;
 use serde_json::Value;
 
-use crate::ai_serving::is_openai_responses_family_format;
+use crate::ai_serving::{normalize_api_format_alias, parse_codex_auth_identity};
 
 use super::state::GatewayProviderTransportSnapshot;
 
-const DEFAULT_CODEX_REQUEST_GZIP_MIN_BYTES: usize = 64 * 1024;
-
-pub(crate) fn resolve_transport_request_gzip_policy(
-    transport: &GatewayProviderTransportSnapshot,
-) -> Option<AiRequestGzipPolicy> {
-    transport_request_gzip_policy_from_config(transport.endpoint.config.as_ref())
-        .or_else(|| transport_request_gzip_policy_from_config(transport.provider.config.as_ref()))
-        .or_else(|| default_transport_request_gzip_policy(transport))
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub(crate) struct TransportRequestEncodingPolicy {
+    pub content_encoding: Option<String>,
+    pub request_gzip: Option<AiRequestGzipPolicy>,
 }
 
-fn default_transport_request_gzip_policy(
+pub(crate) fn resolve_transport_request_encoding_policy(
     transport: &GatewayProviderTransportSnapshot,
-) -> Option<AiRequestGzipPolicy> {
+) -> TransportRequestEncodingPolicy {
+    if transport
+        .provider
+        .provider_type
+        .trim()
+        .eq_ignore_ascii_case("codex")
+        && normalize_api_format_alias(transport.endpoint.api_format.as_str())
+            == "openai:responses:compact"
+    {
+        return TransportRequestEncodingPolicy::default();
+    }
+
+    let request_gzip = transport_request_gzip_policy_from_config(
+        transport.endpoint.config.as_ref(),
+    )
+    .or_else(|| transport_request_gzip_policy_from_config(transport.provider.config.as_ref()));
+    if request_gzip.is_some() {
+        return TransportRequestEncodingPolicy {
+            content_encoding: None,
+            request_gzip,
+        };
+    }
+
+    TransportRequestEncodingPolicy {
+        content_encoding: default_transport_request_content_encoding(transport),
+        request_gzip: None,
+    }
+}
+
+fn default_transport_request_content_encoding(
+    transport: &GatewayProviderTransportSnapshot,
+) -> Option<String> {
     if !transport
         .provider
         .provider_type
@@ -26,19 +53,24 @@ fn default_transport_request_gzip_policy(
     {
         return None;
     }
-    if !is_codex_request_gzip_endpoint_api_format(transport.endpoint.api_format.as_str()) {
+    if !is_codex_request_compression_api_format(transport.endpoint.api_format.as_str()) {
+        return None;
+    }
+    let auth_type =
+        crate::ai_serving::transport::auth::resolve_local_auth_type_for_transport_format(transport);
+    let uses_codex_backend = auth_type == "oauth"
+        || (auth_type == "bearer"
+            && parse_codex_auth_identity(transport.key.decrypted_auth_config.as_deref())
+                .uses_codex_backend);
+    if !uses_codex_backend {
         return None;
     }
 
-    Some(AiRequestGzipPolicy {
-        enabled: Some(true),
-        min_bytes: Some(DEFAULT_CODEX_REQUEST_GZIP_MIN_BYTES),
-    })
+    Some("zstd".to_string())
 }
 
-fn is_codex_request_gzip_endpoint_api_format(api_format: &str) -> bool {
-    is_openai_responses_family_format(api_format)
-        || api_format.trim().eq_ignore_ascii_case("openai:image")
+fn is_codex_request_compression_api_format(api_format: &str) -> bool {
+    normalize_api_format_alias(api_format) == "openai:responses"
 }
 
 fn transport_request_gzip_policy_from_config(
@@ -216,6 +248,16 @@ mod tests {
         }
     }
 
+    fn resolved_gzip_policy(
+        transport: &GatewayProviderTransportSnapshot,
+    ) -> Option<AiRequestGzipPolicy> {
+        resolve_transport_request_encoding_policy(transport).request_gzip
+    }
+
+    fn resolved_content_encoding(transport: &GatewayProviderTransportSnapshot) -> Option<String> {
+        resolve_transport_request_encoding_policy(transport).content_encoding
+    }
+
     #[test]
     fn endpoint_request_gzip_policy_overrides_provider_policy() {
         let transport = sample_transport(
@@ -226,7 +268,7 @@ mod tests {
         );
 
         assert_eq!(
-            resolve_transport_request_gzip_policy(&transport),
+            resolved_gzip_policy(&transport),
             Some(AiRequestGzipPolicy {
                 enabled: Some(true),
                 min_bytes: Some(1024),
@@ -244,7 +286,7 @@ mod tests {
         );
 
         assert_eq!(
-            resolve_transport_request_gzip_policy(&transport),
+            resolved_gzip_policy(&transport),
             Some(AiRequestGzipPolicy {
                 enabled: Some(false),
                 min_bytes: None,
@@ -265,7 +307,7 @@ mod tests {
         );
 
         assert_eq!(
-            resolve_transport_request_gzip_policy(&transport),
+            resolved_gzip_policy(&transport),
             Some(AiRequestGzipPolicy {
                 enabled: Some(true),
                 min_bytes: Some(4096),
@@ -283,7 +325,7 @@ mod tests {
         );
 
         assert_eq!(
-            resolve_transport_request_gzip_policy(&transport),
+            resolved_gzip_policy(&transport),
             Some(AiRequestGzipPolicy {
                 enabled: Some(true),
                 min_bytes: Some(1),
@@ -292,35 +334,73 @@ mod tests {
     }
 
     #[test]
-    fn codex_responses_endpoint_gets_default_request_gzip_policy() {
-        let transport = sample_transport("codex", "openai:responses", None, None);
+    fn codex_responses_endpoint_uses_zstd_without_a_size_threshold() {
+        let mut transport = sample_transport("codex", "openai:responses", None, None);
+        transport.key.auth_type = "oauth".to_string();
 
         assert_eq!(
-            resolve_transport_request_gzip_policy(&transport),
-            Some(AiRequestGzipPolicy {
-                enabled: Some(true),
-                min_bytes: Some(DEFAULT_CODEX_REQUEST_GZIP_MIN_BYTES),
-            })
+            resolved_content_encoding(&transport).as_deref(),
+            Some("zstd")
         );
+        assert_eq!(resolved_gzip_policy(&transport), None);
     }
 
     #[test]
-    fn codex_image_endpoint_gets_default_request_gzip_policy() {
-        let transport = sample_transport("codex", "openai:image", None, None);
+    fn codex_responses_api_key_auth_does_not_enable_default_compression() {
+        let transport = sample_transport("codex", "openai:responses", None, None);
+
+        assert_eq!(resolved_content_encoding(&transport), None);
+        assert_eq!(resolved_gzip_policy(&transport), None);
+    }
+
+    #[test]
+    fn codex_responses_bearer_auth_uses_identity_metadata_for_backend_compression() {
+        let mut transport = sample_transport("codex", "openai:responses", None, None);
+        transport.key.auth_type = "bearer".to_string();
+        transport.key.decrypted_auth_config =
+            Some(r#"{"provider_type":"codex","account_id":"account-1"}"#.to_string());
 
         assert_eq!(
-            resolve_transport_request_gzip_policy(&transport),
-            Some(AiRequestGzipPolicy {
-                enabled: Some(true),
-                min_bytes: Some(DEFAULT_CODEX_REQUEST_GZIP_MIN_BYTES),
-            })
+            resolved_content_encoding(&transport).as_deref(),
+            Some("zstd")
         );
+        assert_eq!(resolved_gzip_policy(&transport), None);
+    }
+
+    #[test]
+    fn codex_image_endpoint_does_not_get_responses_request_gzip_policy() {
+        let transport = sample_transport("codex", "openai:image", None, None);
+
+        assert_eq!(resolved_content_encoding(&transport), None);
+        assert_eq!(resolved_gzip_policy(&transport), None);
+    }
+
+    #[test]
+    fn codex_compact_endpoint_does_not_get_default_request_gzip_policy() {
+        let transport = sample_transport("codex", "openai:responses:compact", None, None);
+
+        assert_eq!(resolved_content_encoding(&transport), None);
+        assert_eq!(resolved_gzip_policy(&transport), None);
+    }
+
+    #[test]
+    fn codex_compact_endpoint_rejects_an_explicit_request_gzip_policy() {
+        let transport = sample_transport(
+            "codex",
+            "openai:responses:compact",
+            None,
+            Some(json!({"request_gzip": {"enabled": true, "min_bytes": 2048}})),
+        );
+
+        assert_eq!(resolved_gzip_policy(&transport), None);
+        assert_eq!(resolved_content_encoding(&transport), None);
     }
 
     #[test]
     fn non_codex_endpoint_does_not_get_default_request_gzip_policy() {
         let transport = sample_transport("openai", "openai:responses", None, None);
 
-        assert_eq!(resolve_transport_request_gzip_policy(&transport), None);
+        assert_eq!(resolved_content_encoding(&transport), None);
+        assert_eq!(resolved_gzip_policy(&transport), None);
     }
 }

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

@@ -77,6 +77,7 @@ mod tests {
             auth_endpoint_signature: None,
             execution_runtime_candidate: true,
             local_auth_rejection: None,
+            model_directive_policy: Default::default(),
         }
     }
 

apps/aether-gateway/src/ai_serving/planner/specialized/files/decision.rs

@@ -7,7 +7,7 @@ use crate::ai_serving::planner::report_context::{
 };
 use crate::ai_serving::planner::spec_metadata::local_gemini_files_spec_metadata;
 use crate::ai_serving::planner::{
-    build_ai_execution_decision_response, resolve_transport_request_gzip_policy,
+    build_ai_execution_decision_response, resolve_transport_request_encoding_policy,
     AiExecutionDecisionResponseParts,
 };
 use crate::ai_serving::transport::{
@@ -124,7 +124,7 @@ pub(super) async fn maybe_build_local_gemini_files_decision_payload_for_candidat
         upstream_url,
         file_name: _,
     } = resolved;
-    let request_gzip = resolve_transport_request_gzip_policy(&transport);
+    let request_encoding = resolve_transport_request_encoding_policy(&transport);
 
     let mut decision = build_ai_execution_decision_response(AiExecutionDecisionResponseParts {
         decision_is_stream: spec_metadata.require_streaming,
@@ -134,6 +134,7 @@ pub(super) async fn maybe_build_local_gemini_files_decision_payload_for_candidat
         request_id: trace_id.to_string(),
         candidate_id: candidate_id.clone(),
         provider_name: transport.provider.name.clone(),
+        provider_type: transport.provider.provider_type.clone(),
         provider_id: candidate.provider_id.clone(),
         endpoint_id: candidate.endpoint_id.clone(),
         key_id: candidate.key_id.clone(),
@@ -156,8 +157,8 @@ pub(super) async fn maybe_build_local_gemini_files_decision_payload_for_candidat
             .map(str::trim)
             .filter(|value| !value.is_empty())
             .map(ToOwned::to_owned),
-        content_encoding: None,
-        request_gzip,
+        content_encoding: request_encoding.content_encoding,
+        request_gzip: request_encoding.request_gzip,
         proxy,
         transport_profile,
         timeouts: resolve_transport_execution_timeouts(&transport),
@@ -166,6 +167,10 @@ pub(super) async fn maybe_build_local_gemini_files_decision_payload_for_candidat
         report_context: Some(report_context),
         auth_context: input.auth_context.clone(),
     });
-    apply_provider_request_routing_policy_to_decision(input, &mut decision)?;
+    apply_provider_request_routing_policy_to_decision(
+        input,
+        &mut decision,
+        Some(transport.as_ref()),
+    )?;
     Ok(Some(decision))
 }

apps/aether-gateway/src/ai_serving/planner/specialized/files/support.rs

@@ -53,7 +53,9 @@ pub(super) async fn resolve_local_gemini_files_decision_input(
         state,
         auth_context,
         None,
+        decision.auth_endpoint_signature.as_deref(),
         Some(&explicit_required_capabilities),
+        &decision.model_directive_policy,
     )
     .await
     {

apps/aether-gateway/src/ai_serving/planner/specialized/image/decision.rs

@@ -5,7 +5,7 @@ use crate::ai_serving::planner::report_context::{
 };
 use crate::ai_serving::planner::spec_metadata::local_openai_image_spec_metadata;
 use crate::ai_serving::planner::{
-    build_ai_execution_decision_response, resolve_transport_request_gzip_policy,
+    build_ai_execution_decision_response, resolve_transport_request_encoding_policy,
     AiExecutionDecisionResponseParts,
 };
 use crate::ai_serving::transport::{
@@ -84,11 +84,7 @@ pub(super) async fn maybe_build_local_openai_image_decision_payload_for_candidat
             serde_json::Value::Bool(true),
         );
     }
-    let upstream_is_stream = resolved
-        .provider_request_body
-        .get("stream")
-        .and_then(serde_json::Value::as_bool)
-        .unwrap_or(spec_metadata.require_streaming);
+    let upstream_is_stream = resolved.upstream_is_stream;
     let effective_headers = input.effective_headers(&parts.headers);
     let report_context = append_execution_contract_fields_to_value(
         build_local_execution_report_context(LocalExecutionReportContextParts {
@@ -135,7 +131,7 @@ pub(super) async fn maybe_build_local_openai_image_decision_payload_for_candidat
         spec_metadata.api_format,
         provider_api_format.as_str(),
     );
-    let request_gzip = resolve_transport_request_gzip_policy(&transport);
+    let request_encoding = resolve_transport_request_encoding_policy(&transport);
 
     let mut decision = build_ai_execution_decision_response(AiExecutionDecisionResponseParts {
         decision_is_stream: spec_metadata.require_streaming,
@@ -145,6 +141,7 @@ pub(super) async fn maybe_build_local_openai_image_decision_payload_for_candidat
         request_id: trace_id.to_string(),
         candidate_id: candidate_id.clone(),
         provider_name: transport.provider.name.clone(),
+        provider_type: transport.provider.provider_type.clone(),
         provider_id: candidate.provider_id.clone(),
         endpoint_id: candidate.endpoint_id.clone(),
         key_id: candidate.key_id.clone(),
@@ -162,8 +159,8 @@ pub(super) async fn maybe_build_local_openai_image_decision_payload_for_candidat
         provider_request_body: Some(resolved.provider_request_body),
         provider_request_body_base64: None,
         content_type: Some("application/json".to_string()),
-        content_encoding: None,
-        request_gzip,
+        content_encoding: request_encoding.content_encoding,
+        request_gzip: request_encoding.request_gzip,
         proxy,
         transport_profile,
         timeouts: resolve_transport_execution_timeouts(&transport),
@@ -172,6 +169,10 @@ pub(super) async fn maybe_build_local_openai_image_decision_payload_for_candidat
         report_context: Some(report_context),
         auth_context: input.auth_context.clone(),
     });
-    apply_provider_request_routing_policy_to_decision(input, &mut decision)?;
+    apply_provider_request_routing_policy_to_decision(
+        input,
+        &mut decision,
+        Some(transport.as_ref()),
+    )?;
     Ok(Some(decision))
 }

apps/aether-gateway/src/ai_serving/planner/specialized/image/request.rs

@@ -16,8 +16,8 @@ use crate::ai_serving::transport::{
     ProviderOpenAiImageHeadersInput, StandardProviderRequestHeadersInput, GROK_CHAT_PATH,
 };
 use crate::ai_serving::{
-    apply_codex_openai_responses_special_body_edits, apply_codex_openai_responses_special_headers,
-    build_chatgpt_web_image_request_body,
+    apply_codex_openai_special_headers, build_chatgpt_web_image_request_body,
+    build_codex_openai_image_api_provider_request_body,
     build_gemini_image_request_body_from_openai_image_request,
     build_openai_image_api_provider_request_body, build_openai_image_provider_request_body,
     default_model_for_openai_image_operation, normalize_openai_image_request,
@@ -48,6 +48,7 @@ pub(super) struct LocalOpenAiImageCandidatePayloadParts {
     pub(super) upstream_url: String,
     pub(super) input_summary: Value,
     pub(super) transport_profile: Option<ResolvedTransportProfile>,
+    pub(super) upstream_is_stream: bool,
 }
 
 pub(super) async fn resolve_local_openai_image_candidate_payload_parts(
@@ -130,7 +131,10 @@ pub(super) async fn resolve_local_openai_image_candidate_payload_parts(
         parts,
         body_json,
         body_base64,
-        openai_image_normalize_options_for_provider(&transport.provider.provider_type),
+        openai_image_normalize_options_for_provider(
+            &transport.provider.provider_type,
+            Some(prepared_candidate.mapped_model.as_str()),
+        ),
     );
     let Some(normalized_request) = normalized_request else {
         mark_skipped_local_openai_image_candidate_with_failure_diagnostic(
@@ -174,29 +178,56 @@ pub(super) async fn resolve_local_openai_image_candidate_payload_parts(
     } else {
         build_openai_image_upstream_url(transport, Some(parts.uri.path()), parts.uri.query())
     };
-    let mut provider_request_body = if is_chatgpt_web {
-        match build_chatgpt_web_image_request_body(parts, body_json, body_base64) {
-            Ok(body) => body,
-            Err(err) => err.to_error_json(),
-        }
-    } else if is_codex || is_grok {
-        build_openai_image_provider_request_body(&normalized_request)
+    let upstream_is_stream =
+        crate::ai_serving::planner::common::resolve_upstream_is_stream_for_provider(
+            transport.endpoint.config.as_ref(),
+            transport.provider.provider_type.as_str(),
+            spec_metadata.api_format,
+            spec_metadata.require_streaming && candidate.supports_streaming,
+            false,
+        );
+    let provider_request_body = if is_chatgpt_web {
+        Some(
+            match build_chatgpt_web_image_request_body(parts, body_json, body_base64) {
+                Ok(body) => body,
+                Err(err) => err.to_error_json(),
+            },
+        )
+    } else if is_codex {
+        build_codex_openai_image_api_provider_request_body(
+            &normalized_request,
+            Some(prepared_candidate.mapped_model.as_str()),
+            upstream_is_stream,
+        )
+    } else if is_grok {
+        Some(build_openai_image_provider_request_body(
+            &normalized_request,
+        ))
     } else {
         build_openai_image_api_provider_request_body(
             &normalized_request,
             Some(prepared_candidate.mapped_model.as_str()),
+            upstream_is_stream,
         )
     };
-    if !is_chatgpt_web {
-        apply_codex_openai_responses_special_body_edits(
-            &mut provider_request_body,
-            transport.provider.provider_type.as_str(),
-            spec_metadata.api_format,
-            transport.endpoint.body_rules.as_ref(),
-            Some(candidate.key_id.as_str()),
-        );
-    }
-
+    let Some(provider_request_body) = provider_request_body else {
+        mark_skipped_local_openai_image_candidate_with_failure_diagnostic(
+            state,
+            input,
+            trace_id,
+            candidate,
+            attempt.candidate_index,
+            &attempt.candidate_id,
+            "provider_request_body_missing",
+            CandidateFailureDiagnostic::provider_request_body_missing(
+                spec_metadata.api_format,
+                spec_metadata.api_format,
+                "codex_openai_images_request_contract",
+            ),
+        )
+        .await;
+        return None;
+    };
     let Some(mut provider_request_headers) = (if is_grok {
         build_grok_browser_headers(GrokHeaderInput {
             transport,
@@ -214,10 +245,12 @@ pub(super) async fn resolve_local_openai_image_candidate_payload_parts(
             headers: effective_headers,
             auth_header: &auth_header,
             auth_value: &auth_value,
-            accept: if is_codex || is_chatgpt_web {
-                "text/event-stream"
+            accept: if is_codex {
+                None
+            } else if upstream_is_stream {
+                Some("text/event-stream")
             } else {
-                "application/json"
+                Some("application/json")
             },
             header_rules: transport.endpoint.header_rules.as_ref(),
             provider_request_body: &provider_request_body,
@@ -245,7 +278,7 @@ pub(super) async fn resolve_local_openai_image_candidate_payload_parts(
         provider_request_headers.insert("x-aether-chatgpt-web-image".to_string(), "1".to_string());
     } else if is_grok {
     } else {
-        apply_codex_openai_responses_special_headers(
+        apply_codex_openai_special_headers(
             &mut provider_request_headers,
             &provider_request_body,
             effective_headers,
@@ -287,6 +320,7 @@ pub(super) async fn resolve_local_openai_image_candidate_payload_parts(
         upstream_url,
         input_summary,
         transport_profile,
+        upstream_is_stream,
     })
 }
 
@@ -403,7 +437,14 @@ async fn resolve_local_openai_image_to_gemini_candidate_payload_parts(
                 return None;
             }
         };
-    let upstream_is_stream = spec_metadata.require_streaming;
+    let upstream_is_stream =
+        crate::ai_serving::planner::common::resolve_upstream_is_stream_for_provider(
+            transport.endpoint.config.as_ref(),
+            transport.provider.provider_type.as_str(),
+            provider_api_format,
+            spec_metadata.require_streaming && candidate.supports_streaming,
+            false,
+        );
     let Some(upstream_url) = crate::ai_serving::planner::standard::build_standard_upstream_url(
         parts,
         transport,
@@ -474,6 +515,7 @@ async fn resolve_local_openai_image_to_gemini_candidate_payload_parts(
         upstream_url,
         input_summary: converted.summary_json,
         transport_profile: None,
+        upstream_is_stream,
     })
 }
 

apps/aether-gateway/src/ai_serving/planner/specialized/image/support.rs

@@ -58,7 +58,9 @@ pub(super) async fn resolve_local_openai_image_decision_input(
         state,
         auth_context,
         Some(requested_model.as_str()),
+        decision.auth_endpoint_signature.as_deref(),
         None,
+        &decision.model_directive_policy,
     )
     .await
     {
@@ -124,6 +126,7 @@ pub(super) async fn list_local_openai_image_candidate_attempts(
                 matches_client_format.then_some(&input.auth_snapshot),
                 input.client_session_affinity.as_ref(),
                 current_unix_secs(),
+                false,
             )
             .await
         {
@@ -144,8 +147,8 @@ pub(super) async fn list_local_openai_image_candidate_attempts(
                 auth_snapshot_allows_cross_format_candidate(
                     &input.auth_snapshot,
                     &input.requested_model,
+                    None,
                     candidate,
-                    false,
                 )
             });
         }
@@ -197,6 +200,7 @@ pub(super) async fn build_local_openai_image_candidate_attempt_source<'a>(
                 matches_client_format.then_some(&input.auth_snapshot),
                 input.client_session_affinity.as_ref(),
                 current_unix_secs(),
+                false,
             )
             .await
         {
@@ -206,16 +210,16 @@ pub(super) async fn build_local_openai_image_candidate_attempt_source<'a>(
                         auth_snapshot_allows_cross_format_candidate(
                             &input.auth_snapshot,
                             &input.requested_model,
+                            None,
                             candidate,
-                            false,
                         )
                     });
                     format_skipped.retain(|candidate| {
                         auth_snapshot_allows_cross_format_candidate(
                             &input.auth_snapshot,
                             &input.requested_model,
+                            None,
                             &candidate.candidate,
-                            false,
                         )
                     });
                 }

apps/aether-gateway/src/ai_serving/planner/specialized/video/decision.rs

@@ -5,7 +5,7 @@ use crate::ai_serving::planner::report_context::{
 };
 use crate::ai_serving::planner::spec_metadata::local_video_create_spec_metadata;
 use crate::ai_serving::planner::{
-    build_ai_execution_decision_response, resolve_transport_request_gzip_policy,
+    build_ai_execution_decision_response, resolve_transport_request_encoding_policy,
     AiExecutionDecisionResponseParts,
 };
 use crate::ai_serving::transport::{
@@ -104,7 +104,7 @@ pub(super) async fn maybe_build_local_video_create_decision_payload_for_candidat
         provider_request_body,
         upstream_url,
     } = resolved;
-    let request_gzip = resolve_transport_request_gzip_policy(&transport);
+    let request_encoding = resolve_transport_request_encoding_policy(&transport);
 
     let mut decision = build_ai_execution_decision_response(AiExecutionDecisionResponseParts {
         decision_is_stream: false,
@@ -114,6 +114,7 @@ pub(super) async fn maybe_build_local_video_create_decision_payload_for_candidat
         request_id: trace_id.to_string(),
         candidate_id: candidate_id.clone(),
         provider_name: transport.provider.name.clone(),
+        provider_type: transport.provider.provider_type.clone(),
         provider_id: candidate.provider_id.clone(),
         endpoint_id: candidate.endpoint_id.clone(),
         key_id: candidate.key_id.clone(),
@@ -137,8 +138,8 @@ pub(super) async fn maybe_build_local_video_create_decision_payload_for_candidat
             .map(str::trim)
             .filter(|value| !value.is_empty())
             .map(ToOwned::to_owned),
-        content_encoding: None,
-        request_gzip,
+        content_encoding: request_encoding.content_encoding,
+        request_gzip: request_encoding.request_gzip,
         proxy,
         transport_profile,
         timeouts: resolve_transport_execution_timeouts(&transport),
@@ -147,6 +148,10 @@ pub(super) async fn maybe_build_local_video_create_decision_payload_for_candidat
         report_context: Some(report_context),
         auth_context: input.auth_context.clone(),
     });
-    apply_provider_request_routing_policy_to_decision(input, &mut decision)?;
+    apply_provider_request_routing_policy_to_decision(
+        input,
+        &mut decision,
+        Some(transport.as_ref()),
+    )?;
     Ok(Some(decision))
 }

apps/aether-gateway/src/ai_serving/planner/specialized/video/support.rs

@@ -62,7 +62,9 @@ pub(super) async fn resolve_local_video_create_decision_input(
         state,
         auth_context,
         Some(requested_model.as_str()),
+        decision.auth_endpoint_signature.as_deref(),
         None,
+        &decision.model_directive_policy,
     )
     .await
     {
@@ -130,6 +132,7 @@ pub(super) async fn list_local_video_create_candidate_attempts(
             Some(&input.auth_snapshot),
             input.client_session_affinity.as_ref(),
             current_unix_secs(),
+            false,
         )
         .await
     {
@@ -186,6 +189,7 @@ pub(super) async fn build_local_video_create_candidate_attempt_source<'a>(
             Some(&input.auth_snapshot),
             input.client_session_affinity.as_ref(),
             current_unix_secs(),
+            false,
         )
         .await
     {

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

@@ -3,5 +3,42 @@
 mod tests;
 
 pub(crate) use crate::ai_serving::{
-    apply_codex_openai_responses_special_body_edits, apply_codex_openai_responses_special_headers,
+    apply_codex_openai_responses_special_body_edits, apply_codex_openai_special_headers,
 };
+
+pub(crate) fn codex_model_capabilities_for_transport(
+    transport: &crate::ai_serving::GatewayProviderTransportSnapshot,
+    provider_api_format: &str,
+    provider_model: &str,
+    source_model: &str,
+) -> Option<crate::ai_serving::CodexResponsesModelCapabilities> {
+    codex_model_capabilities(
+        &transport.provider.provider_type,
+        provider_api_format,
+        provider_model,
+        source_model,
+        transport.key.upstream_metadata.as_ref(),
+    )
+}
+
+fn codex_model_capabilities(
+    provider_type: &str,
+    provider_api_format: &str,
+    provider_model: &str,
+    source_model: &str,
+    upstream_metadata: Option<&serde_json::Value>,
+) -> Option<crate::ai_serving::CodexResponsesModelCapabilities> {
+    let uses_codex_model_catalog =
+        crate::ai_serving::is_openai_responses_family_format(provider_api_format)
+            || crate::ai_serving::api_format_alias_matches(provider_api_format, "openai:search");
+    if !provider_type.trim().eq_ignore_ascii_case("codex") || !uses_codex_model_catalog {
+        return None;
+    }
+    Some(
+        crate::ai_serving::resolve_codex_responses_model_capabilities(
+            provider_model,
+            source_model,
+            upstream_metadata,
+        ),
+    )
+}

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

@@ -1,16 +1,56 @@
 use std::collections::BTreeMap;
 
 use super::{
-    apply_codex_openai_responses_special_body_edits, apply_codex_openai_responses_special_headers,
+    apply_codex_openai_responses_special_body_edits, apply_codex_openai_special_headers,
+    codex_model_capabilities,
 };
 use crate::ai_serving::planner::standard::build_local_openai_responses_request_body;
 use http::{HeaderMap, HeaderValue};
 use serde_json::json;
 
+#[test]
+fn search_uses_live_codex_model_catalog_capabilities() {
+    let metadata = crate::ai_serving::build_codex_model_catalog_metadata(&[json!({
+        "slug": "gpt-search-custom",
+        "default_reasoning_level": "low",
+        "supported_reasoning_levels": [
+            {"effort": "low"},
+            {"effort": "max"}
+        ],
+        "supports_parallel_tool_calls": true
+    })]);
+
+    let capabilities = codex_model_capabilities(
+        "codex",
+        "openai:search",
+        "gpt-search-custom",
+        "gpt-search-custom",
+        Some(&metadata),
+    )
+    .expect("Search should resolve capabilities from the Codex model catalog");
+
+    assert_eq!(
+        capabilities.default_reasoning_effort.as_deref(),
+        Some("low")
+    );
+    assert_eq!(
+        capabilities.supported_reasoning_efforts,
+        vec!["low".to_string(), "max".to_string()]
+    );
+    assert!(codex_model_capabilities(
+        "codex",
+        "openai:chat",
+        "gpt-search-custom",
+        "gpt-search-custom",
+        Some(&metadata),
+    )
+    .is_none());
+}
+
 #[test]
 fn applies_codex_defaults_when_body_rules_do_not_handle_fields() {
     let mut body = json!({
-        "model": "gpt-5",
+        "model": "gpt-5.4",
         "max_output_tokens": 128,
         "temperature": 0.3,
         "top_p": 0.9,
@@ -31,10 +71,11 @@ fn applies_codex_defaults_when_body_rules_do_not_handle_fields() {
     assert!(body.get("top_p").is_none());
     assert!(body.get("metadata").is_none());
     assert_eq!(body["store"], false);
-    assert_eq!(body["instructions"], "");
+    assert!(body.get("instructions").is_none());
     assert_eq!(body["include"], json!(["reasoning.encrypted_content"]));
     assert_eq!(body["parallel_tool_calls"], true);
-    assert!(body.get("reasoning").is_none());
+    assert_eq!(body["reasoning"]["effort"], "medium");
+    assert!(body["reasoning"].get("summary").is_none());
 }
 
 #[test]
@@ -80,7 +121,7 @@ fn strips_store_for_compact_even_when_body_rules_handle_it() {
         {"action":"set","path":"top_p","value":0.5}
     ]);
     let mut body = json!({
-        "model": "gpt-5",
+        "model": "gpt-5.4",
         "max_output_tokens": 128,
         "metadata": {"client": "desktop", "mode": "custom"},
         "store": true,
@@ -99,12 +140,29 @@ fn strips_store_for_compact_even_when_body_rules_handle_it() {
     assert!(body.get("max_output_tokens").is_none());
     assert!(body.get("store").is_none());
     assert_eq!(body["instructions"], "Keep custom");
-    assert_eq!(body["metadata"]["mode"], "custom");
-    assert_eq!(body["top_p"], 0.5);
+    assert!(body.get("metadata").is_none());
+    assert!(body.get("top_p").is_none());
+    assert_eq!(body["parallel_tool_calls"], true);
+    assert!(body.as_object().is_some_and(|object| {
+        object.keys().all(|field| {
+            matches!(
+                field.as_str(),
+                "model"
+                    | "input"
+                    | "instructions"
+                    | "tools"
+                    | "parallel_tool_calls"
+                    | "reasoning"
+                    | "service_tier"
+                    | "prompt_cache_key"
+                    | "text"
+            )
+        })
+    }));
 }
 
 #[test]
-fn injects_stable_prompt_cache_key_for_codex_requests() {
+fn does_not_synthesize_prompt_cache_key_from_api_key_identity() {
     let mut body = json!({
         "model": "gpt-5",
         "input": "hello",
@@ -118,10 +176,7 @@ fn injects_stable_prompt_cache_key_for_codex_requests() {
         Some("key-123"),
     );
 
-    assert_eq!(
-        body["prompt_cache_key"],
-        "53363264-dbb0-5f9d-b9c7-3e92c45c5bdf"
-    );
+    assert!(body.get("prompt_cache_key").is_none());
 }
 
 #[test]
@@ -144,57 +199,96 @@ fn keeps_existing_prompt_cache_key_for_codex_requests() {
 }
 
 #[test]
-fn injects_chatgpt_account_id_and_session_headers_for_codex_requests() {
+fn injects_identity_headers_without_deriving_session_headers_from_body() {
     let mut headers = BTreeMap::new();
     let body = json!({
         "model": "gpt-5",
         "prompt_cache_key": "172c39e6-c0a0-5a70-8b63-e0f8e0d185a3",
     });
 
-    apply_codex_openai_responses_special_headers(
+    apply_codex_openai_special_headers(
         &mut headers,
         &body,
         &HeaderMap::new(),
         "codex",
         "openai:responses",
         Some("trace-codex-123"),
-        Some(r#"{"account_id":"acc-123"}"#),
+        Some(r#"{"account_id":"acc-123","is_fedramp":true}"#),
+    );
+
+    assert_eq!(
+        headers.get("chatgpt-account-id"),
+        Some(&"acc-123".to_string())
+    );
+    assert_eq!(headers.get("x-client-request-id"), None);
+    assert_eq!(
+        headers.get("user-agent"),
+        Some(&"codex_cli_rs/0.144.1".to_string())
+    );
+    assert_eq!(headers.get("originator"), Some(&"codex_cli_rs".to_string()));
+    assert!(!headers.contains_key("version"));
+    assert_eq!(headers.get("x-openai-fedramp"), Some(&"true".to_string()));
+    assert_eq!(headers.get("session-id"), None);
+    assert_eq!(headers.get("thread-id"), None);
+}
+
+#[test]
+fn injects_only_codex_client_headers_for_images_requests() {
+    let mut headers = BTreeMap::new();
+    apply_codex_openai_special_headers(
+        &mut headers,
+        &json!({
+            "model": "gpt-image-2",
+            "prompt": "draw a city"
+        }),
+        &HeaderMap::new(),
+        "codex",
+        "openai:image",
+        Some("trace-codex-image-123"),
+        Some(r#"{"account_id":"acc-123","is_fedramp":true}"#),
     );
 
     assert_eq!(
         headers.get("chatgpt-account-id"),
         Some(&"acc-123".to_string())
     );
-    assert_eq!(
-        headers.get("x-client-request-id"),
-        Some(&"trace-codex-123".to_string())
-    );
     assert_eq!(
         headers.get("user-agent"),
-        Some(
-            &"codex-tui/0.122.0 (Mac OS 15.2.0; arm64) vscode/2.6.11 (codex-tui; 0.122.0)"
-                .to_string()
-        )
-    );
-    assert_eq!(headers.get("originator"), Some(&"codex-tui".to_string()));
-    assert_eq!(
-        headers.get("session_id"),
-        Some(&"ab5ecce4f0d110fe".to_string())
-    );
-    assert_eq!(
-        headers.get("conversation_id"),
-        Some(&"ab5ecce4f0d110fe".to_string())
+        Some(&"codex_cli_rs/0.144.1".to_string())
     );
+    assert_eq!(headers.get("originator"), Some(&"codex_cli_rs".to_string()));
+    assert!(!headers.contains_key("version"));
+    assert_eq!(headers.get("x-openai-fedramp"), Some(&"true".to_string()));
+    for name in ["x-client-request-id", "session-id", "thread-id"] {
+        assert!(
+            !headers.contains_key(name),
+            "unexpected Images header: {name}"
+        );
+    }
 }
 
 #[test]
-fn respects_existing_codex_request_and_session_headers() {
+fn preserves_client_context_headers_and_enforces_codex_provider_identity() {
     let mut headers = BTreeMap::new();
     headers.insert(
         "x-client-request-id".to_string(),
         "kept-by-rule-request".to_string(),
     );
-    headers.insert("session_id".to_string(), "kept-by-rule".to_string());
+    headers.insert("session-id".to_string(), "kept-by-rule-session".to_string());
+    headers.insert("thread-id".to_string(), "kept-by-rule-thread".to_string());
+    headers.insert(
+        "chatgpt-account-id".to_string(),
+        "configured-spoof".to_string(),
+    );
+    headers.insert(
+        "x-openai-fedramp".to_string(),
+        "configured-false".to_string(),
+    );
+    headers.insert(
+        "User-Agent".to_string(),
+        "AsyncOpenAI/Python 2.44.0".to_string(),
+    );
+    headers.insert("ORIGINATOR".to_string(), "sdk-client".to_string());
     let body = json!({
         "model": "gpt-5",
         "prompt_cache_key": "172c39e6-c0a0-5a70-8b63-e0f8e0d185a3",
@@ -205,12 +299,12 @@ fn respects_existing_codex_request_and_session_headers() {
         HeaderValue::from_static("user-specified-request"),
     );
     original_headers.insert(
-        "session_id",
+        "session-id",
         HeaderValue::from_static("user-specified-session"),
     );
     original_headers.insert(
-        "conversation_id",
-        HeaderValue::from_static("user-specified-conversation"),
+        "thread-id",
+        HeaderValue::from_static("user-specified-thread"),
     );
     original_headers.insert(
         "user-agent",
@@ -220,64 +314,92 @@ fn respects_existing_codex_request_and_session_headers() {
         "originator",
         HeaderValue::from_static("user-specified-originator"),
     );
+    original_headers.insert("version", HeaderValue::from_static("user-version"));
+    original_headers.insert("x-openai-fedramp", HeaderValue::from_static("user-fedramp"));
+    original_headers.insert(
+        "chatgpt-account-id",
+        HeaderValue::from_static("user-account"),
+    );
 
-    apply_codex_openai_responses_special_headers(
+    apply_codex_openai_special_headers(
         &mut headers,
         &body,
         &original_headers,
         "codex",
         "openai:responses",
         Some("trace-codex-123"),
-        Some(r#"{"account_id":"acc-123"}"#),
+        Some(r#"{"account_id":"acc-123","is_fedramp":true}"#),
     );
 
     assert_eq!(
         headers.get("x-client-request-id"),
         Some(&"kept-by-rule-request".to_string())
     );
-    assert!(!headers.contains_key("user-agent"));
-    assert!(!headers.contains_key("originator"));
-    assert_eq!(headers.get("session_id"), Some(&"kept-by-rule".to_string()));
-    assert!(!headers.contains_key("conversation_id"));
+    assert_eq!(
+        headers.get("user-agent"),
+        Some(&"codex_cli_rs/0.144.1".to_string())
+    );
+    assert_eq!(headers.get("originator"), Some(&"codex_cli_rs".to_string()));
+    assert_eq!(
+        headers
+            .keys()
+            .filter(|name| name.eq_ignore_ascii_case("user-agent"))
+            .count(),
+        1
+    );
+    assert_eq!(
+        headers
+            .keys()
+            .filter(|name| name.eq_ignore_ascii_case("originator"))
+            .count(),
+        1
+    );
+    assert!(!headers.contains_key("version"));
+    assert_eq!(
+        headers.get("chatgpt-account-id"),
+        Some(&"acc-123".to_string())
+    );
+    assert_eq!(headers.get("x-openai-fedramp"), Some(&"true".to_string()));
+    assert_eq!(
+        headers.get("session-id"),
+        Some(&"kept-by-rule-session".to_string())
+    );
+    assert_eq!(
+        headers.get("thread-id"),
+        Some(&"kept-by-rule-thread".to_string())
+    );
 }
 
 #[test]
-fn skips_conversation_id_for_compact_codex_requests() {
+fn compact_does_not_derive_session_headers_from_body() {
     let mut headers = BTreeMap::new();
     let body = json!({
         "model": "gpt-5",
         "prompt_cache_key": "172c39e6-c0a0-5a70-8b63-e0f8e0d185a3",
     });
 
-    apply_codex_openai_responses_special_headers(
+    apply_codex_openai_special_headers(
         &mut headers,
         &body,
         &HeaderMap::new(),
         "codex",
         "openai:responses:compact",
         Some("trace-codex-compact-123"),
-        Some(r#"{"account_id":"acc-123"}"#),
+        Some(r#"{"account_id":"acc-123","is_fedramp":true}"#),
     );
 
     assert_eq!(
         headers.get("chatgpt-account-id"),
         Some(&"acc-123".to_string())
     );
-    assert_eq!(
-        headers.get("x-client-request-id"),
-        Some(&"trace-codex-compact-123".to_string())
-    );
+    assert_eq!(headers.get("x-client-request-id"), None);
     assert_eq!(
         headers.get("user-agent"),
-        Some(
-            &"codex-tui/0.122.0 (Mac OS 15.2.0; arm64) vscode/2.6.11 (codex-tui; 0.122.0)"
-                .to_string()
-        )
+        Some(&"codex_cli_rs/0.144.1".to_string())
     );
-    assert_eq!(headers.get("originator"), Some(&"codex-tui".to_string()));
-    assert_eq!(
-        headers.get("session_id"),
-        Some(&"ab5ecce4f0d110fe".to_string())
-    );
-    assert!(!headers.contains_key("conversation_id"));
+    assert_eq!(headers.get("originator"), Some(&"codex_cli_rs".to_string()));
+    assert!(!headers.contains_key("version"));
+    assert_eq!(headers.get("x-openai-fedramp"), Some(&"true".to_string()));
+    assert_eq!(headers.get("session-id"), None);
+    assert_eq!(headers.get("thread-id"), None);
 }

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

@@ -60,7 +60,9 @@ pub(super) async fn resolve_local_standard_decision_input(
         state,
         auth_context,
         Some(requested_model.as_str()),
+        decision.auth_endpoint_signature.as_deref(),
         None,
+        &decision.model_directive_policy,
     )
     .await
     {
@@ -119,8 +121,10 @@ pub(super) async fn materialize_local_standard_candidate_attempts(
     );
     let preselection = preselect_local_execution_candidates_with_serving(
         planner_state,
+        &input.model_directive_policy,
         spec_metadata.api_format,
         &input.requested_model,
+        None,
         false,
         input.required_capabilities.as_ref(),
         &input.auth_snapshot,
@@ -243,9 +247,11 @@ pub(super) async fn build_local_standard_candidate_attempt_source<'a>(
     let (source, candidate_count) =
         build_lazy_requested_model_execution_candidate_attempt_source_with_serving(
             planner_state,
+            &input.model_directive_policy,
             trace_id,
             spec_metadata.api_format,
             &input.requested_model,
+            None,
             spec_metadata.require_streaming,
             &input.auth_snapshot,
             input.client_session_affinity.as_ref(),
@@ -338,8 +344,10 @@ async fn maybe_append_gemini_image_openai_image_preselection(
 
     let image_preselection = preselect_local_execution_candidates_for_api_formats_with_serving(
         planner_state,
+        &input.model_directive_policy,
         spec_metadata.api_format,
         &input.requested_model,
+        None,
         spec_metadata.require_streaming,
         input.required_capabilities.as_ref(),
         &input.auth_snapshot,

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

@@ -15,7 +15,7 @@ use crate::ai_serving::planner::report_context::{
 use crate::ai_serving::planner::spec_metadata::local_standard_spec_metadata;
 use crate::ai_serving::planner::CandidateFailureDiagnostic;
 use crate::ai_serving::planner::{
-    build_ai_execution_decision_response, resolve_transport_request_gzip_policy,
+    build_ai_execution_decision_response, resolve_transport_request_encoding_policy,
     AiExecutionDecisionResponseParts,
 };
 use crate::ai_serving::transport::{
@@ -176,7 +176,7 @@ pub(super) async fn maybe_build_local_standard_decision_payload_for_candidate(
         transport_profile: _,
         request_redacted: _,
     } = resolved;
-    let request_gzip = resolve_transport_request_gzip_policy(&transport);
+    let request_encoding = resolve_transport_request_encoding_policy(&transport);
 
     let mut decision = build_ai_execution_decision_response(AiExecutionDecisionResponseParts {
         decision_is_stream: spec_metadata.require_streaming,
@@ -186,6 +186,7 @@ pub(super) async fn maybe_build_local_standard_decision_payload_for_candidate(
         request_id: trace_id.to_string(),
         candidate_id: candidate_id.to_string(),
         provider_name: candidate.provider_name.clone(),
+        provider_type: transport.provider.provider_type.clone(),
         provider_id: candidate.provider_id.clone(),
         endpoint_id: candidate.endpoint_id.clone(),
         key_id: candidate.key_id.clone(),
@@ -203,8 +204,8 @@ pub(super) async fn maybe_build_local_standard_decision_payload_for_candidate(
         provider_request_body: Some(provider_request_body),
         provider_request_body_base64: None,
         content_type: Some("application/json".to_string()),
-        content_encoding: None,
-        request_gzip,
+        content_encoding: request_encoding.content_encoding,
+        request_gzip: request_encoding.request_gzip,
         proxy,
         transport_profile,
         timeouts,
@@ -213,7 +214,11 @@ pub(super) async fn maybe_build_local_standard_decision_payload_for_candidate(
         report_context: Some(report_context),
         auth_context: input.auth_context.clone(),
     });
-    apply_provider_request_routing_policy_to_decision(input, &mut decision)?;
+    apply_provider_request_routing_policy_to_decision(
+        input,
+        &mut decision,
+        Some(transport.as_ref()),
+    )?;
     Ok(Some(decision))
 }
 
@@ -372,6 +377,7 @@ mod tests {
             routing_policy: None,
             routing_trace_seed: None,
             routing_context: None,
+            model_directive_policy: Default::default(),
         }
     }
 
@@ -475,6 +481,7 @@ mod tests {
             } else {
                 "gpt-4o-upstream".to_string()
             },
+            supports_streaming: true,
             mapping_matched_model: None,
         }
     }

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

@@ -21,9 +21,9 @@ use crate::ai_serving::planner::redaction::{
 };
 use crate::ai_serving::planner::spec_metadata::local_standard_spec_metadata;
 use crate::ai_serving::planner::standard::{
-    apply_codex_openai_responses_special_headers, apply_deepseek_tool_call_thinking_compat,
-    is_deepseek_provider, request_body_build_failure_extra_data,
-    request_conversion_failure_extra_data,
+    apply_codex_openai_special_headers, apply_deepseek_tool_call_thinking_compat,
+    codex_model_capabilities_for_transport, is_deepseek_provider,
+    request_body_build_failure_extra_data, request_conversion_failure_extra_data,
 };
 use crate::ai_serving::transport::kiro::{
     build_kiro_provider_headers, build_kiro_provider_request_body,
@@ -44,7 +44,9 @@ use crate::ai_serving::transport::{
 };
 use crate::ai_serving::{
     build_openai_image_request_body_from_gemini_image_request, gemini_request_is_image_generation,
+    project_codex_openai_image_api_request_body, project_openai_image_api_request_body,
     CandidateFailureDiagnostic, GatewayProviderTransportSnapshot, LocalResolvedOAuthRequestAuth,
+    OpenAiImageOperation,
 };
 use crate::{AppState, GatewayError};
 
@@ -313,7 +315,13 @@ pub(crate) async fn resolve_local_standard_candidate_payload_parts(
     {
         return Ok(
             resolve_local_gemini_image_to_openai_image_candidate_payload_parts(
-                state, parts, trace_id, body_json, input, attempt,
+                state,
+                parts,
+                trace_id,
+                body_json,
+                input,
+                attempt,
+                spec_metadata.require_streaming,
             )
             .await,
         );
@@ -555,13 +563,27 @@ pub(crate) async fn resolve_local_standard_candidate_payload_parts(
     );
     let force_body_stream_field =
         endpoint_config_forces_body_stream_field(transport.endpoint.config.as_ref());
-    let enable_model_directives =
-        crate::system_features::reasoning_model_directive_enabled_for_api_format_and_model(
-            state,
-            provider_api_format,
-            Some(&input.requested_model),
-        )
-        .await;
+    let model_directive_resolution = input
+        .model_directive_policy
+        .resolve_reasoning(provider_api_format, Some(&input.requested_model));
+    let model_directive_mapping = match model_directive_resolution
+        .mapping_patch_for_mapped_model(&prepared_candidate.mapped_model)
+    {
+        Ok(mapping) => mapping,
+        Err(skip_reason) => {
+            mark_skipped_local_standard_candidate(
+                state,
+                input,
+                trace_id,
+                candidate,
+                attempt.candidate_index,
+                &attempt.candidate_id,
+                skip_reason,
+            )
+            .await;
+            return Ok(None);
+        }
+    };
     let redaction = resolve_provider_chat_pii_redaction(
         state,
         parts,
@@ -588,7 +610,7 @@ pub(crate) async fn resolve_local_standard_candidate_payload_parts(
             },
             Some(input.auth_context.api_key_id.as_str()),
             Some(effective_headers),
-            enable_model_directives,
+            false,
         ) {
             Some(body) => body,
             None => {
@@ -655,18 +677,8 @@ pub(crate) async fn resolve_local_standard_candidate_payload_parts(
         provider_api_format,
         Some(body_json),
     );
-    if let Some(mapping) =
-        crate::system_features::reasoning_model_directive_mapping_for_api_format_and_model(
-            state,
-            provider_api_format,
-            Some(&input.requested_model),
-        )
-        .await
-    {
-        crate::ai_serving::apply_model_directive_mapping_patch(
-            &mut provider_request_body,
-            &mapping,
-        );
+    if let Some(mapping) = model_directive_mapping.as_ref() {
+        crate::ai_serving::apply_model_directive_mapping_patch(&mut provider_request_body, mapping);
         // Directive mapping is a deep-merge patch and may overwrite/add `stream`;
         // re-enforce stream-field policy afterward.
         enforce_provider_body_stream_policy(
@@ -712,6 +724,64 @@ pub(crate) async fn resolve_local_standard_candidate_payload_parts(
         );
     }
 
+    let normalized_provider_api_format =
+        crate::ai_serving::normalize_api_format_alias(provider_api_format);
+    if matches!(
+        normalized_provider_api_format.as_str(),
+        "openai:chat" | "openai:responses" | "openai:responses:compact"
+    ) {
+        let source_model = body_json
+            .get("model")
+            .and_then(Value::as_str)
+            .unwrap_or(input.requested_model.as_str());
+        let codex_model_capabilities = codex_model_capabilities_for_transport(
+            transport,
+            provider_api_format,
+            prepared_candidate.mapped_model.as_str(),
+            source_model,
+        );
+        if crate::ai_serving::finalize_openai_provider_request_with_codex_model_capabilities(
+            &mut provider_request_body,
+            crate::ai_serving::OpenAiProviderRequestFinalization {
+                source_api_format: spec_metadata.api_format,
+                provider_api_format,
+                provider_type: transport.provider.provider_type.as_str(),
+                provider_model: prepared_candidate.mapped_model.as_str(),
+                source_model,
+                body_rules: transport.endpoint.body_rules.as_ref(),
+                upstream_is_stream,
+                require_body_stream_field: request_requires_body_stream_field(
+                    body_json,
+                    force_body_stream_field,
+                ),
+            },
+            codex_model_capabilities.as_ref(),
+        )
+        .is_err()
+        {
+            mark_skipped_local_standard_candidate_with_extra_data(
+                state,
+                input,
+                trace_id,
+                candidate,
+                attempt.candidate_index,
+                &attempt.candidate_id,
+                "provider_request_body_build_failed",
+                request_conversion_failure_extra_data(
+                    body_json,
+                    spec_metadata.api_format,
+                    provider_api_format,
+                    Some(prepared_candidate.mapped_model.as_str()),
+                    Some(parts.uri.path()),
+                    upstream_is_stream,
+                    "standard_family_request_finalization",
+                ),
+            )
+            .await;
+            return Ok(None);
+        }
+    }
+
     if let Some(kiro_auth) = kiro_auth.as_ref() {
         return Ok(build_kiro_cross_format_payload_parts(
             state,
@@ -752,8 +822,6 @@ pub(crate) async fn resolve_local_standard_candidate_payload_parts(
         .await);
     }
 
-    let normalized_provider_api_format =
-        crate::ai_serving::normalize_api_format_alias(provider_api_format);
     if normalized_provider_api_format == "gemini:generate_content"
         && is_gemini_cli_provider_transport(transport)
     {
@@ -838,7 +906,7 @@ pub(crate) async fn resolve_local_standard_candidate_payload_parts(
         return Ok(None);
     };
     let mut provider_request_headers = resolved_headers.headers;
-    apply_codex_openai_responses_special_headers(
+    apply_codex_openai_special_headers(
         &mut provider_request_headers,
         &provider_request_body,
         effective_headers,
@@ -988,7 +1056,7 @@ async fn build_gemini_cli_cross_format_payload_parts(
         };
 
     let mut provider_request_headers = resolved.headers.headers;
-    apply_codex_openai_responses_special_headers(
+    apply_codex_openai_special_headers(
         &mut provider_request_headers,
         &resolved.body,
         effective_headers,
@@ -1146,6 +1214,7 @@ async fn resolve_local_gemini_image_to_openai_image_candidate_payload_parts(
     body_json: &serde_json::Value,
     input: &LocalStandardDecisionInput,
     attempt: &LocalStandardCandidateAttempt,
+    client_requires_streaming: bool,
 ) -> Option<LocalStandardCandidatePayloadParts> {
     let client_api_format = "gemini:generate_content";
     let provider_api_format = "openai:image";
@@ -1221,9 +1290,44 @@ async fn resolve_local_gemini_image_to_openai_image_candidate_payload_parts(
         return None;
     };
 
-    let upstream_is_stream = true;
-    let upstream_url =
-        build_openai_image_upstream_url(transport, Some("/v1/images/generations"), None);
+    let upstream_is_stream = resolve_upstream_is_stream_for_provider(
+        transport.endpoint.config.as_ref(),
+        transport.provider.provider_type.as_str(),
+        provider_api_format,
+        client_requires_streaming && candidate.supports_streaming,
+        false,
+    );
+    let is_codex = transport
+        .provider
+        .provider_type
+        .trim()
+        .eq_ignore_ascii_case("codex");
+    let mut provider_request_body = converted.body_json;
+    if upstream_is_stream {
+        provider_request_body
+            .as_object_mut()?
+            .insert("stream".to_string(), Value::Bool(true));
+    }
+    provider_request_body = project_openai_image_api_request_body(
+        &provider_request_body,
+        &prepared_candidate.mapped_model,
+        converted.operation,
+        crate::image_capabilities::openai_image_provider_max_generation_count_for_model(
+            transport.provider.provider_type.as_str(),
+            Some(prepared_candidate.mapped_model.as_str()),
+        ),
+    )?;
+    if is_codex {
+        provider_request_body = project_codex_openai_image_api_request_body(
+            &provider_request_body,
+            converted.operation,
+        )?;
+    }
+    let request_path = match converted.operation {
+        OpenAiImageOperation::Generate => "/v1/images/generations",
+        OpenAiImageOperation::Edit => "/v1/images/edits",
+    };
+    let upstream_url = build_openai_image_upstream_url(transport, Some(request_path), None);
     let effective_headers = input.effective_headers(&parts.headers);
     let Some(mut provider_request_headers) =
         build_openai_image_headers(ProviderOpenAiImageHeadersInput {
@@ -1231,9 +1335,15 @@ async fn resolve_local_gemini_image_to_openai_image_candidate_payload_parts(
             headers: effective_headers,
             auth_header: &prepared_candidate.auth_header,
             auth_value: &prepared_candidate.auth_value,
-            accept: "text/event-stream",
+            accept: if is_codex {
+                None
+            } else if upstream_is_stream {
+                Some("text/event-stream")
+            } else {
+                Some("application/json")
+            },
             header_rules: transport.endpoint.header_rules.as_ref(),
-            provider_request_body: &converted.body_json,
+            provider_request_body: &provider_request_body,
             original_request_body: body_json,
         })
     else {
@@ -1254,9 +1364,9 @@ async fn resolve_local_gemini_image_to_openai_image_candidate_payload_parts(
         .await;
         return None;
     };
-    apply_codex_openai_responses_special_headers(
+    apply_codex_openai_special_headers(
         &mut provider_request_headers,
-        &converted.body_json,
+        &provider_request_body,
         effective_headers,
         transport.provider.provider_type.as_str(),
         provider_api_format,
@@ -1269,7 +1379,7 @@ async fn resolve_local_gemini_image_to_openai_image_candidate_payload_parts(
         auth_value: prepared_candidate.auth_value,
         mapped_model: converted.mapped_model,
         provider_api_format: provider_api_format.to_string(),
-        provider_request_body: converted.body_json,
+        provider_request_body,
         provider_request_headers,
         upstream_url,
         upstream_is_stream,

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

@@ -15,7 +15,8 @@ mod normalize;
 mod openai;
 
 pub(crate) use self::codex::{
-    apply_codex_openai_responses_special_body_edits, apply_codex_openai_responses_special_headers,
+    apply_codex_openai_responses_special_body_edits, apply_codex_openai_special_headers,
+    codex_model_capabilities_for_transport,
 };
 pub(crate) use self::deepseek::{apply_deepseek_tool_call_thinking_compat, is_deepseek_provider};
 pub(crate) use self::family::{
@@ -25,9 +26,11 @@ pub(crate) use self::family::{
 pub(crate) use self::normalize::{
     build_cross_format_openai_chat_request_body, build_cross_format_openai_chat_upstream_url,
     build_cross_format_openai_responses_request_body,
+    build_cross_format_openai_responses_request_body_with_codex_model_capabilities,
     build_cross_format_openai_responses_upstream_url, build_local_openai_chat_request_body,
     build_local_openai_chat_upstream_url, build_local_openai_responses_request_body,
-    build_local_openai_responses_upstream_url,
+    build_local_openai_responses_request_body_with_codex_model_capabilities,
+    build_local_openai_responses_upstream_url, validate_final_openai_provider_request,
 };
 pub(crate) use self::openai::{
     build_local_openai_chat_stream_attempt_source_for_kind,
@@ -297,7 +300,7 @@ mod tests {
         let converted = build_standard_request_body(
             &request,
             "claude:messages",
-            "gpt-5",
+            "gpt-5.4",
             "codex",
             "openai:responses",
             "/v1/messages",
@@ -309,7 +312,7 @@ mod tests {
 
         assert!(converted.get("metadata").is_none());
         assert_eq!(converted["store"], false);
-        assert_eq!(converted["instructions"], "");
+        assert!(converted.get("instructions").is_none());
         assert_eq!(converted["include"], json!(["reasoning.encrypted_content"]));
         assert_eq!(converted["parallel_tool_calls"], true);
         assert_eq!(converted["reasoning"]["effort"], "medium");

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

@@ -12,9 +12,38 @@ pub(crate) use self::chat::{
 };
 pub(crate) use self::responses::{
     build_cross_format_openai_responses_request_body,
+    build_cross_format_openai_responses_request_body_with_codex_model_capabilities,
     build_cross_format_openai_responses_upstream_url, build_local_openai_responses_request_body,
+    build_local_openai_responses_request_body_with_codex_model_capabilities,
     build_local_openai_responses_upstream_url,
 };
 pub(super) use crate::ai_serving::planner::common::{
     enforce_provider_body_stream_policy, request_requires_body_stream_field,
 };
+
+pub(crate) fn validate_final_openai_provider_request(
+    provider_api_format: &str,
+    mapped_model: &str,
+    source_request_body: &serde_json::Value,
+    provider_request_body: &serde_json::Value,
+) -> Option<()> {
+    let provider_model = provider_request_body
+        .get("model")
+        .and_then(serde_json::Value::as_str)
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .unwrap_or(mapped_model);
+    let source_model = source_request_body
+        .get("model")
+        .and_then(serde_json::Value::as_str)
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .unwrap_or(mapped_model);
+    crate::ai_serving::validate_openai_provider_request_contract(
+        provider_api_format,
+        provider_model,
+        source_model,
+        provider_request_body,
+    )
+    .ok()
+}

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

@@ -9,7 +9,10 @@ use crate::ai_serving::{
     GatewayProviderTransportSnapshot,
 };
 
-use super::{enforce_provider_body_stream_policy, request_requires_body_stream_field};
+use super::{
+    enforce_provider_body_stream_policy, request_requires_body_stream_field,
+    validate_final_openai_provider_request,
+};
 
 pub(crate) fn build_local_openai_chat_request_body(
     body_json: &Value,
@@ -39,6 +42,12 @@ pub(crate) fn build_local_openai_chat_request_body(
         upstream_is_stream,
         request_requires_body_stream_field(body_json, force_body_stream_field),
     );
+    validate_final_openai_provider_request(
+        "openai:chat",
+        mapped_model,
+        body_json,
+        &provider_request_body,
+    )?;
     Some(provider_request_body)
 }
 
@@ -92,6 +101,12 @@ pub(crate) fn build_cross_format_openai_chat_request_body(
         upstream_is_stream,
         request_requires_body_stream_field(body_json, force_body_stream_field),
     );
+    validate_final_openai_provider_request(
+        provider_api_format,
+        mapped_model,
+        body_json,
+        &provider_request_body,
+    )?;
     Some(provider_request_body)
 }
 

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

@@ -2,14 +2,16 @@ use serde_json::Value;
 
 use crate::ai_serving::transport::apply_standard_provider_request_body_rules_with_request_headers;
 use crate::ai_serving::{
-    apply_codex_openai_responses_special_body_edits,
     apply_openai_responses_compact_special_body_edits,
     build_cross_format_openai_responses_request_body_with_model_directives as surface_build_cross_format_openai_responses_request_body,
     build_local_openai_responses_request_body_with_model_directives as surface_build_local_openai_responses_request_body,
     GatewayProviderTransportSnapshot,
 };
 
-use super::{enforce_provider_body_stream_policy, request_requires_body_stream_field};
+use super::{
+    enforce_provider_body_stream_policy, request_requires_body_stream_field,
+    validate_final_openai_provider_request,
+};
 
 pub(crate) fn build_local_openai_responses_request_body(
     body_json: &Value,
@@ -19,9 +21,35 @@ pub(crate) fn build_local_openai_responses_request_body(
     provider_type: &str,
     provider_api_format: &str,
     body_rules: Option<&Value>,
-    user_api_key_id: Option<&str>,
+    _user_api_key_id: Option<&str>,
     request_headers: &http::HeaderMap,
     enable_model_directives: bool,
+) -> Option<Value> {
+    build_local_openai_responses_request_body_with_codex_model_capabilities(
+        body_json,
+        mapped_model,
+        require_streaming,
+        force_body_stream_field,
+        provider_type,
+        provider_api_format,
+        body_rules,
+        request_headers,
+        None,
+        enable_model_directives,
+    )
+}
+
+pub(crate) fn build_local_openai_responses_request_body_with_codex_model_capabilities(
+    body_json: &Value,
+    mapped_model: &str,
+    require_streaming: bool,
+    force_body_stream_field: bool,
+    provider_type: &str,
+    provider_api_format: &str,
+    body_rules: Option<&Value>,
+    request_headers: &http::HeaderMap,
+    model_capabilities: Option<&crate::ai_serving::CodexResponsesModelCapabilities>,
+    enable_model_directives: bool,
 ) -> Option<Value> {
     let provider_request_body = surface_build_local_openai_responses_request_body(
         body_json,
@@ -36,12 +64,18 @@ pub(crate) fn build_local_openai_responses_request_body(
             body_json,
             request_headers,
         )?;
-    apply_codex_openai_responses_special_body_edits(
+    let source_model = body_json
+        .get("model")
+        .and_then(Value::as_str)
+        .unwrap_or(mapped_model);
+    crate::ai_serving::apply_codex_openai_responses_special_body_edits_with_source_model_and_capabilities(
         &mut provider_request_body,
         provider_type,
         provider_api_format,
+        mapped_model,
+        source_model,
+        model_capabilities,
         body_rules,
-        user_api_key_id,
     );
     apply_openai_responses_compact_special_body_edits(
         &mut provider_request_body,
@@ -53,6 +87,12 @@ pub(crate) fn build_local_openai_responses_request_body(
         require_streaming,
         request_requires_body_stream_field(body_json, force_body_stream_field),
     );
+    validate_final_openai_provider_request(
+        provider_api_format,
+        mapped_model,
+        body_json,
+        &provider_request_body,
+    )?;
     Some(provider_request_body)
 }
 
@@ -65,9 +105,37 @@ pub(crate) fn build_cross_format_openai_responses_request_body(
     force_body_stream_field: bool,
     provider_type: &str,
     body_rules: Option<&Value>,
-    user_api_key_id: Option<&str>,
+    _user_api_key_id: Option<&str>,
     request_headers: &http::HeaderMap,
     enable_model_directives: bool,
+) -> Option<Value> {
+    build_cross_format_openai_responses_request_body_with_codex_model_capabilities(
+        body_json,
+        mapped_model,
+        client_api_format,
+        provider_api_format,
+        upstream_is_stream,
+        force_body_stream_field,
+        provider_type,
+        body_rules,
+        request_headers,
+        None,
+        enable_model_directives,
+    )
+}
+
+pub(crate) fn build_cross_format_openai_responses_request_body_with_codex_model_capabilities(
+    body_json: &Value,
+    mapped_model: &str,
+    client_api_format: &str,
+    provider_api_format: &str,
+    upstream_is_stream: bool,
+    force_body_stream_field: bool,
+    provider_type: &str,
+    body_rules: Option<&Value>,
+    request_headers: &http::HeaderMap,
+    model_capabilities: Option<&crate::ai_serving::CodexResponsesModelCapabilities>,
+    enable_model_directives: bool,
 ) -> Option<Value> {
     let provider_request_body = surface_build_cross_format_openai_responses_request_body(
         body_json,
@@ -84,12 +152,18 @@ pub(crate) fn build_cross_format_openai_responses_request_body(
             body_json,
             request_headers,
         )?;
-    apply_codex_openai_responses_special_body_edits(
+    let source_model = body_json
+        .get("model")
+        .and_then(Value::as_str)
+        .unwrap_or(mapped_model);
+    crate::ai_serving::apply_codex_openai_responses_special_body_edits_with_source_model_and_capabilities(
         &mut provider_request_body,
         provider_type,
         provider_api_format,
+        mapped_model,
+        source_model,
+        model_capabilities,
         body_rules,
-        user_api_key_id,
     );
     apply_openai_responses_compact_special_body_edits(
         &mut provider_request_body,
@@ -101,6 +175,12 @@ pub(crate) fn build_cross_format_openai_responses_request_body(
         upstream_is_stream,
         request_requires_body_stream_field(body_json, force_body_stream_field),
     );
+    validate_final_openai_provider_request(
+        provider_api_format,
+        mapped_model,
+        body_json,
+        &provider_request_body,
+    )?;
     Some(provider_request_body)
 }
 

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

@@ -6,8 +6,8 @@ use http::Request;
 use serde_json::{json, Value};
 
 use super::{
-    build_cross_format_openai_responses_request_body, build_local_openai_responses_request_body,
-    build_local_openai_responses_upstream_url,
+    build_cross_format_openai_responses_request_body, build_local_openai_chat_request_body,
+    build_local_openai_responses_request_body, build_local_openai_responses_upstream_url,
 };
 
 fn object_keys(value: &Value) -> Vec<&str> {
@@ -146,12 +146,10 @@ fn local_openai_responses_wrapper_preserves_body_order_after_edits() {
             "reasoning",
             "tool_choice",
             "parallel_tool_calls",
-            "instructions",
-            "prompt_cache_key",
         ]
     );
     assert_eq!(provider_request_body["parallel_tool_calls"], json!(true));
-    assert_eq!(provider_request_body["instructions"], json!(""));
+    assert!(provider_request_body.get("instructions").is_none());
 }
 
 #[test]
@@ -181,18 +179,49 @@ fn local_openai_responses_compact_wrapper_strips_store_for_same_format_requests(
 }
 
 #[test]
-fn local_openai_responses_compact_wrapper_strips_include_for_codex_requests() {
+fn local_codex_compact_wrapper_applies_the_complete_request_projection() {
     let body_json = json!({
-        "model": "gpt-5.4",
-        "input": [],
+        "model": "gpt-5.6-sol",
+        "input": [{
+            "type": "message",
+            "role": "user",
+            "content": [{"type": "input_text", "text": "hello"}]
+        }],
+        "instructions": "Work carefully",
+        "client_metadata": {"origin": "codex"},
         "include": ["reasoning.encrypted_content"],
         "store": true,
-        "stream": true
+        "stream": true,
+        "stream_options": {"reasoning_summary_delivery": "sequential_cutoff"},
+        "tool_choice": "auto",
+        "parallel_tool_calls": true,
+        "reasoning": {"effort": "max", "summary": "auto", "context": "all_turns"},
+        "text": {"verbosity": "medium"},
+        "tools": [{
+            "type": "function",
+            "name": "lookup",
+            "parameters": {"type": "object", "properties": {}}
+        }],
+        "service_tier": "priority",
+        "prompt_cache_key": "thread-compact"
     });
 
-    let provider_request_body = build_local_openai_responses_request_body(
+    let regular = build_local_openai_responses_request_body(
         &body_json,
-        "gpt-5.4",
+        "gpt-5.6-sol",
+        true,
+        false,
+        "codex",
+        "openai:responses",
+        None,
+        Some("key-123"),
+        &http::HeaderMap::new(),
+        false,
+    )
+    .expect("local Codex Responses body should build");
+    let compact = build_local_openai_responses_request_body(
+        &body_json,
+        "gpt-5.6-sol",
         false,
         false,
         "codex",
@@ -202,22 +231,44 @@ fn local_openai_responses_compact_wrapper_strips_include_for_codex_requests() {
         &http::HeaderMap::new(),
         false,
     )
-    .expect("local codex compact body should build");
+    .expect("local Codex Compact body should build");
 
-    assert!(provider_request_body.get("include").is_none());
-    assert!(provider_request_body.get("store").is_none());
-    assert!(provider_request_body.get("stream").is_none());
-    assert_eq!(provider_request_body["instructions"], "");
-    assert_eq!(
-        provider_request_body["prompt_cache_key"],
-        "3d2e2842-74cb-55dd-803a-b8940b3500c2"
-    );
+    for field in [
+        "client_metadata",
+        "include",
+        "store",
+        "stream",
+        "stream_options",
+        "tool_choice",
+    ] {
+        assert!(
+            regular.get(field).is_some(),
+            "Responses should contain {field}"
+        );
+        assert!(compact.get(field).is_none(), "Compact should omit {field}");
+    }
+    for field in [
+        "model",
+        "input",
+        "instructions",
+        "parallel_tool_calls",
+        "reasoning",
+        "text",
+        "tools",
+        "service_tier",
+        "prompt_cache_key",
+    ] {
+        assert_eq!(
+            compact[field], regular[field],
+            "Compact should preserve {field}"
+        );
+    }
 }
 
 #[test]
 fn local_openai_responses_wrapper_applies_model_directive_before_body_rules() {
     let body_json = json!({
-        "model": "gpt-5.4-max",
+        "model": "gpt-5.6-sol-max",
         "input": "hello",
         "reasoning": {"effort": "low", "summary": "auto"}
     });
@@ -227,7 +278,7 @@ fn local_openai_responses_wrapper_applies_model_directive_before_body_rules() {
 
     let provider_request_body = build_local_openai_responses_request_body(
         &body_json,
-        "gpt-5.4",
+        "gpt-5.6-sol",
         false,
         false,
         "openai",
@@ -244,6 +295,132 @@ fn local_openai_responses_wrapper_applies_model_directive_before_body_rules() {
     assert_eq!(provider_request_body["metadata"]["override_seen"], true);
 }
 
+#[test]
+fn final_openai_provider_contract_uses_the_mapped_model_for_reasoning() {
+    let alias = json!({
+        "model": "deployment-alias",
+        "input": "hello",
+        "reasoning": {"effort": "max"}
+    });
+    assert!(build_local_openai_responses_request_body(
+        &alias,
+        "gpt-5.6-sol",
+        false,
+        false,
+        "openai",
+        "openai:responses",
+        None,
+        None,
+        &http::HeaderMap::new(),
+        false,
+    )
+    .is_some());
+    assert!(build_local_openai_responses_request_body(
+        &alias,
+        "gpt-5.4",
+        false,
+        false,
+        "openai",
+        "openai:responses",
+        None,
+        None,
+        &http::HeaderMap::new(),
+        false,
+    )
+    .is_none());
+
+    let minimal = json!({
+        "model": "deployment-alias",
+        "messages": [{"role": "user", "content": "hello"}],
+        "reasoning_effort": "minimal"
+    });
+    assert!(build_local_openai_chat_request_body(
+        &minimal,
+        "gpt-5.6-terra",
+        false,
+        false,
+        None,
+        &http::HeaderMap::new(),
+        false,
+    )
+    .is_none());
+
+    let opaque_mapping = json!({
+        "model": "gpt-5.6-sol-max",
+        "input": "hello",
+        "reasoning": {"effort": "max", "mode": "pro"},
+        "prompt_cache_options": {"mode": "explicit", "ttl": "30m"}
+    });
+    assert!(build_local_openai_responses_request_body(
+        &opaque_mapping,
+        "azure-production",
+        false,
+        false,
+        "openai",
+        "openai:responses",
+        None,
+        None,
+        &http::HeaderMap::new(),
+        false,
+    )
+    .is_some());
+    assert!(build_local_openai_responses_request_body(
+        &opaque_mapping,
+        "gpt-5.4",
+        false,
+        false,
+        "openai",
+        "openai:responses",
+        None,
+        None,
+        &http::HeaderMap::new(),
+        false,
+    )
+    .is_none());
+}
+
+#[test]
+fn final_openai_provider_contract_validates_body_rule_output() {
+    let body = json!({
+        "model": "gpt-5.6-sol",
+        "input": "hello",
+        "reasoning": {"effort": "max"}
+    });
+    let model_override = json!([
+        {"action":"set","path":"model","value":"gpt-5.4"}
+    ]);
+    assert!(build_local_openai_responses_request_body(
+        &body,
+        "gpt-5.6-sol",
+        false,
+        false,
+        "openai",
+        "openai:responses",
+        Some(&model_override),
+        None,
+        &http::HeaderMap::new(),
+        false,
+    )
+    .is_none());
+
+    let cache_override = json!([
+        {"action":"set","path":"prompt_cache_options.ttl","value":"1h"}
+    ]);
+    assert!(build_local_openai_responses_request_body(
+        &json!({"model":"gpt-5.6-sol","input":"hello"}),
+        "gpt-5.6-sol",
+        false,
+        false,
+        "openai",
+        "openai:responses",
+        Some(&cache_override),
+        None,
+        &http::HeaderMap::new(),
+        false,
+    )
+    .is_none());
+}
+
 #[test]
 fn local_openai_responses_upstream_url_preserves_codex_base_path() {
     let request = Request::builder()
@@ -371,7 +548,7 @@ fn applies_codex_defaults_unless_body_rules_handle_the_field() {
 }
 
 #[test]
-fn injects_codex_prompt_cache_key_for_openai_responses_cross_format_requests() {
+fn omits_codex_prompt_cache_key_for_openai_responses_cross_format_requests() {
     let body_json = json!({
         "model": "claude-sonnet-4-5",
         "messages": [{
@@ -395,14 +572,11 @@ fn injects_codex_prompt_cache_key_for_openai_responses_cross_format_requests() {
     )
     .expect("claude cli to codex request should build");
 
-    assert_eq!(
-        provider_request_body["prompt_cache_key"],
-        "4ee6ea6e-3ac6-5a18-8cb8-1f8b956419e5"
-    );
+    assert!(provider_request_body.get("prompt_cache_key").is_none());
 }
 
 #[test]
-fn injects_codex_prompt_cache_key_for_openai_chat_cross_format_requests() {
+fn omits_codex_prompt_cache_key_for_openai_chat_cross_format_requests() {
     let body_json = json!({
         "model": "gpt-5",
         "messages": [{
@@ -425,8 +599,5 @@ fn injects_codex_prompt_cache_key_for_openai_chat_cross_format_requests() {
     )
     .expect("openai chat to codex request should build");
 
-    assert_eq!(
-        provider_request_body["prompt_cache_key"],
-        "4ee6ea6e-3ac6-5a18-8cb8-1f8b956419e5"
-    );
+    assert!(provider_request_body.get("prompt_cache_key").is_none());
 }

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

@@ -6,7 +6,7 @@ use crate::ai_serving::planner::report_context::{
     insert_provider_stream_event_api_format, LocalExecutionReportContextParts,
 };
 use crate::ai_serving::planner::{
-    build_ai_execution_decision_response, resolve_transport_request_gzip_policy,
+    build_ai_execution_decision_response, resolve_transport_request_encoding_policy,
     AiExecutionDecisionResponseParts,
 };
 use crate::ai_serving::transport::{
@@ -44,6 +44,7 @@ pub(crate) async fn maybe_build_local_openai_chat_decision_payload_for_candidate
         candidate_id,
         ..
     } = attempt;
+    let upstream_is_stream = upstream_is_stream && eligible.candidate.supports_streaming;
     let payload_started_at = std::time::Instant::now();
     let Some(resolved) = resolve_local_openai_chat_candidate_payload_parts(
         state,
@@ -72,6 +73,14 @@ pub(crate) async fn maybe_build_local_openai_chat_decision_payload_for_candidate
         payload_started_at.elapsed().as_millis() as u64,
     );
     let candidate = &eligible.candidate;
+    let upstream_is_stream =
+        crate::ai_serving::planner::common::resolve_upstream_is_stream_for_provider(
+            resolved.transport.endpoint.config.as_ref(),
+            resolved.transport.provider.provider_type.as_str(),
+            resolved.provider_api_format.as_str(),
+            upstream_is_stream,
+            false,
+        );
 
     let prompt_cache_key = resolved
         .provider_request_body
@@ -208,7 +217,7 @@ pub(crate) async fn maybe_build_local_openai_chat_decision_payload_for_candidate
         "stream_candidate_report_context",
         report_context_started_at.elapsed().as_millis() as u64,
     );
-    let request_gzip = resolve_transport_request_gzip_policy(&transport);
+    let request_encoding = resolve_transport_request_encoding_policy(&transport);
 
     let decision_started_at = std::time::Instant::now();
     let mut decision = build_ai_execution_decision_response(AiExecutionDecisionResponseParts {
@@ -219,6 +228,7 @@ pub(crate) async fn maybe_build_local_openai_chat_decision_payload_for_candidate
         request_id: trace_id.to_string(),
         candidate_id: candidate_id.clone(),
         provider_name: transport.provider.name.clone(),
+        provider_type: transport.provider.provider_type.clone(),
         provider_id: candidate.provider_id.clone(),
         endpoint_id: candidate.endpoint_id.clone(),
         key_id: candidate.key_id.clone(),
@@ -236,8 +246,8 @@ pub(crate) async fn maybe_build_local_openai_chat_decision_payload_for_candidate
         provider_request_body: Some(provider_request_body),
         provider_request_body_base64: None,
         content_type: Some("application/json".to_string()),
-        content_encoding: None,
-        request_gzip,
+        content_encoding: request_encoding.content_encoding,
+        request_gzip: request_encoding.request_gzip,
         proxy,
         transport_profile,
         timeouts,
@@ -246,7 +256,11 @@ pub(crate) async fn maybe_build_local_openai_chat_decision_payload_for_candidate
         report_context: Some(report_context),
         auth_context: input.auth_context.clone(),
     });
-    apply_provider_request_routing_policy_to_decision(input, &mut decision)?;
+    apply_provider_request_routing_policy_to_decision(
+        input,
+        &mut decision,
+        Some(transport.as_ref()),
+    )?;
     observe_gateway_stage_ms(
         "stream_candidate_decision_build",
         decision_started_at.elapsed().as_millis() as u64,

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

@@ -25,11 +25,11 @@ use crate::ai_serving::planner::redaction::{
     request_identity_response_encoding_when_redacted, resolve_provider_chat_pii_redaction,
 };
 use crate::ai_serving::planner::standard::{
-    apply_codex_openai_responses_special_body_edits, apply_codex_openai_responses_special_headers,
+    apply_codex_openai_responses_special_body_edits, apply_codex_openai_special_headers,
     apply_deepseek_tool_call_thinking_compat, build_cross_format_openai_chat_request_body,
     build_cross_format_openai_chat_upstream_url, build_local_openai_chat_request_body,
-    build_local_openai_chat_upstream_url, request_body_build_failure_extra_data,
-    request_conversion_failure_extra_data,
+    build_local_openai_chat_upstream_url, codex_model_capabilities_for_transport,
+    request_body_build_failure_extra_data, request_conversion_failure_extra_data,
 };
 use crate::ai_serving::transport::antigravity::is_antigravity_provider_transport;
 use crate::ai_serving::transport::auth::resolve_local_openai_bearer_auth;
@@ -56,7 +56,10 @@ use crate::ai_serving::transport::{
 use crate::ai_serving::{
     ai_local_execution_contract_for_formats, request_conversion_direct_auth,
     request_conversion_kind, CandidateFailureDiagnostic, GatewayProviderTransportSnapshot,
-    LocalResolvedOAuthRequestAuth,
+    LocalResolvedOAuthRequestAuth, OpenAiImageOperation,
+};
+use crate::ai_serving::{
+    project_codex_openai_image_api_request_body, project_openai_image_api_request_body,
 };
 use crate::ai_serving::{ConversionMode, ExecutionStrategy};
 use crate::stage_metrics::observe_gateway_stage_ms;
@@ -88,37 +91,7 @@ pub(crate) struct LocalOpenAiChatCandidatePayloadParts {
 }
 
 #[derive(Default)]
-pub(crate) struct LocalOpenAiChatRequestPreparation {
-    model_directives_enabled: BTreeMap<(String, String), bool>,
-}
-
-impl LocalOpenAiChatRequestPreparation {
-    async fn model_directives_enabled(
-        &mut self,
-        state: &AppState,
-        provider_api_format: &str,
-        requested_model: &str,
-    ) -> bool {
-        let key = (
-            provider_api_format.trim().to_ascii_lowercase(),
-            requested_model.trim().to_string(),
-        );
-        if let Some(enabled) = self.model_directives_enabled.get(&key) {
-            crate::stage_metrics::record_openai_chat_model_directive_cache_hit();
-            return *enabled;
-        }
-        crate::stage_metrics::record_openai_chat_model_directive_cache_miss();
-        let enabled =
-            crate::system_features::reasoning_model_directive_enabled_for_api_format_and_model(
-                state,
-                provider_api_format,
-                Some(requested_model),
-            )
-            .await;
-        self.model_directives_enabled.insert(key, enabled);
-        enabled
-    }
-}
+pub(crate) struct LocalOpenAiChatRequestPreparation;
 
 fn is_grok_text_provider_api_format(provider_api_format: &str) -> bool {
     matches!(
@@ -127,6 +100,65 @@ fn is_grok_text_provider_api_format(provider_api_format: &str) -> bool {
     )
 }
 
+fn finalize_openai_chat_provider_request_body(
+    provider_request_body: &mut Value,
+    custom_directive_mapping: Option<&Value>,
+    provider_api_format: &str,
+    upstream_is_stream: bool,
+    force_body_stream_field: bool,
+    original_body: &Value,
+    transport: &GatewayProviderTransportSnapshot,
+    mapped_model: &str,
+) -> bool {
+    if let Some(mapping) = custom_directive_mapping {
+        crate::ai_serving::apply_model_directive_mapping_patch(provider_request_body, mapping);
+    }
+
+    // Mapping and endpoint body rules can both write `stream`. The resolved transport
+    // policy is authoritative and therefore runs after every body mutation.
+    enforce_provider_body_stream_policy(
+        provider_request_body,
+        provider_api_format,
+        upstream_is_stream,
+        request_requires_body_stream_field(original_body, force_body_stream_field),
+    );
+    apply_deepseek_tool_call_thinking_compat(
+        provider_request_body,
+        transport.provider.provider_type.as_str(),
+        transport.endpoint.base_url.as_str(),
+        provider_api_format,
+        Some(original_body),
+    );
+    let source_model = original_body
+        .get("model")
+        .and_then(Value::as_str)
+        .unwrap_or(mapped_model);
+    let codex_model_capabilities = codex_model_capabilities_for_transport(
+        transport,
+        provider_api_format,
+        mapped_model,
+        source_model,
+    );
+    crate::ai_serving::finalize_openai_provider_request_with_codex_model_capabilities(
+        provider_request_body,
+        crate::ai_serving::OpenAiProviderRequestFinalization {
+            source_api_format: "openai:chat",
+            provider_api_format,
+            provider_type: transport.provider.provider_type.as_str(),
+            provider_model: mapped_model,
+            source_model,
+            body_rules: transport.endpoint.body_rules.as_ref(),
+            upstream_is_stream,
+            require_body_stream_field: request_requires_body_stream_field(
+                original_body,
+                force_body_stream_field,
+            ),
+        },
+        codex_model_capabilities.as_ref(),
+    )
+    .is_ok()
+}
+
 #[allow(clippy::too_many_arguments)]
 pub(crate) async fn resolve_local_openai_chat_candidate_payload_parts(
     state: &AppState,
@@ -134,7 +166,7 @@ pub(crate) async fn resolve_local_openai_chat_candidate_payload_parts(
     trace_id: &str,
     body_json: &serde_json::Value,
     input: &LocalOpenAiChatDecisionInput,
-    mut preparation: Option<&mut LocalOpenAiChatRequestPreparation>,
+    _preparation: Option<&mut LocalOpenAiChatRequestPreparation>,
     eligible: &EligibleLocalExecutionCandidate,
     candidate_index: u32,
     candidate_id: &str,
@@ -151,18 +183,9 @@ pub(crate) async fn resolve_local_openai_chat_candidate_payload_parts(
     let force_body_stream_field =
         endpoint_config_forces_body_stream_field(transport.endpoint.config.as_ref());
     let model_directives_started_at = std::time::Instant::now();
-    let enable_model_directives = if let Some(preparation) = preparation {
-        preparation
-            .model_directives_enabled(state, provider_api_format, &input.requested_model)
-            .await
-    } else {
-        crate::system_features::reasoning_model_directive_enabled_for_api_format_and_model(
-            state,
-            provider_api_format,
-            Some(&input.requested_model),
-        )
-        .await
-    };
+    let model_directive_resolution = input
+        .model_directive_policy
+        .resolve_reasoning(provider_api_format, Some(&input.requested_model));
     observe_gateway_stage_ms(
         "openai_chat_payload_model_directives",
         model_directives_started_at.elapsed().as_millis() as u64,
@@ -220,15 +243,33 @@ pub(crate) async fn resolve_local_openai_chat_candidate_payload_parts(
                 return Ok(None);
             }
         };
+        let model_directive_mapping = match model_directive_resolution
+            .mapping_patch_for_mapped_model(&prepared_candidate.mapped_model)
+        {
+            Ok(mapping) => mapping,
+            Err(skip_reason) => {
+                mark_skipped_local_openai_chat_candidate(
+                    state,
+                    input,
+                    trace_id,
+                    candidate,
+                    candidate_index,
+                    candidate_id,
+                    skip_reason,
+                )
+                .await;
+                return Ok(None);
+            }
+        };
 
-        let Some(provider_request_body) = build_local_openai_chat_request_body(
+        let Some(mut provider_request_body) = build_local_openai_chat_request_body(
             body_json,
             &prepared_candidate.mapped_model,
             upstream_is_stream,
             force_body_stream_field,
             transport.endpoint.body_rules.as_ref(),
             effective_headers,
-            enable_model_directives,
+            false,
         ) else {
             mark_skipped_local_openai_chat_candidate_with_extra_data(
                 state,
@@ -247,6 +288,33 @@ pub(crate) async fn resolve_local_openai_chat_candidate_payload_parts(
             .await;
             return Ok(None);
         };
+        if !finalize_openai_chat_provider_request_body(
+            &mut provider_request_body,
+            model_directive_mapping.as_ref(),
+            provider_api_format,
+            upstream_is_stream,
+            force_body_stream_field,
+            body_json,
+            transport,
+            &prepared_candidate.mapped_model,
+        ) {
+            mark_skipped_local_openai_chat_candidate_with_extra_data(
+                state,
+                input,
+                trace_id,
+                candidate,
+                candidate_index,
+                candidate_id,
+                "provider_request_body_build_failed",
+                request_body_build_failure_extra_data(
+                    body_json,
+                    "openai:chat",
+                    provider_api_format,
+                ),
+            )
+            .await;
+            return Ok(None);
+        }
 
         let upstream_url = build_grok_upstream_url(transport, GROK_CHAT_PATH);
         let Some(mut provider_request_headers) = build_grok_browser_headers(GrokHeaderInput {
@@ -379,6 +447,24 @@ pub(crate) async fn resolve_local_openai_chat_candidate_payload_parts(
                 return Ok(None);
             }
         };
+        let model_directive_mapping = match model_directive_resolution
+            .mapping_patch_for_mapped_model(&prepared_candidate.mapped_model)
+        {
+            Ok(mapping) => mapping,
+            Err(skip_reason) => {
+                mark_skipped_local_openai_chat_candidate(
+                    state,
+                    input,
+                    trace_id,
+                    candidate,
+                    candidate_index,
+                    candidate_id,
+                    skip_reason,
+                )
+                .await;
+                return Ok(None);
+            }
+        };
         observe_gateway_stage_ms(
             "openai_chat_payload_auth_prepare",
             auth_prepare_started_at.elapsed().as_millis() as u64,
@@ -392,7 +478,7 @@ pub(crate) async fn resolve_local_openai_chat_candidate_payload_parts(
             force_body_stream_field,
             transport.endpoint.body_rules.as_ref(),
             effective_headers,
-            enable_model_directives,
+            false,
         ) else {
             mark_skipped_local_openai_chat_candidate_with_extra_data(
                 state,
@@ -415,13 +501,33 @@ pub(crate) async fn resolve_local_openai_chat_candidate_payload_parts(
             "openai_chat_payload_body_build",
             body_build_started_at.elapsed().as_millis() as u64,
         );
-        apply_deepseek_tool_call_thinking_compat(
+        if !finalize_openai_chat_provider_request_body(
             &mut provider_request_body,
-            transport.provider.provider_type.as_str(),
-            transport.endpoint.base_url.as_str(),
+            model_directive_mapping.as_ref(),
             "openai:chat",
-            Some(body_json),
-        );
+            upstream_is_stream,
+            force_body_stream_field,
+            body_json,
+            transport,
+            &prepared_candidate.mapped_model,
+        ) {
+            mark_skipped_local_openai_chat_candidate_with_extra_data(
+                state,
+                input,
+                trace_id,
+                candidate,
+                candidate_index,
+                candidate_id,
+                "provider_request_body_build_failed",
+                request_body_build_failure_extra_data(
+                    body_json,
+                    "openai:chat",
+                    provider_api_format,
+                ),
+            )
+            .await;
+            return Ok(None);
+        }
 
         let Some(upstream_url) = build_local_openai_chat_upstream_url(parts, transport) else {
             mark_skipped_local_openai_chat_candidate_with_failure_diagnostic(
@@ -475,7 +581,7 @@ pub(crate) async fn resolve_local_openai_chat_candidate_payload_parts(
             return Ok(None);
         };
         let mut provider_request_headers = resolved_headers.headers;
-        apply_codex_openai_responses_special_headers(
+        apply_codex_openai_special_headers(
             &mut provider_request_headers,
             &provider_request_body,
             effective_headers,
@@ -651,6 +757,24 @@ pub(crate) async fn resolve_local_openai_chat_candidate_payload_parts(
             }
         }
     };
+    let model_directive_mapping = match model_directive_resolution
+        .mapping_patch_for_mapped_model(&prepared_candidate.mapped_model)
+    {
+        Ok(mapping) => mapping,
+        Err(skip_reason) => {
+            mark_skipped_local_openai_chat_candidate(
+                state,
+                input,
+                trace_id,
+                candidate,
+                candidate_index,
+                candidate_id,
+                skip_reason,
+            )
+            .await;
+            return Ok(None);
+        }
+    };
 
     let Some(mut provider_request_body) = build_cross_format_openai_chat_request_body(
         body_json,
@@ -666,7 +790,7 @@ pub(crate) async fn resolve_local_openai_chat_candidate_payload_parts(
         },
         Some(input.auth_context.api_key_id.as_str()),
         effective_headers,
-        enable_model_directives,
+        false,
     ) else {
         mark_skipped_local_openai_chat_candidate_with_extra_data(
             state,
@@ -689,34 +813,37 @@ pub(crate) async fn resolve_local_openai_chat_candidate_payload_parts(
         .await;
         return Ok(None);
     };
-    if let Some(mapping) =
-        crate::system_features::reasoning_model_directive_mapping_for_api_format_and_model(
-            state,
-            provider_api_format.as_str(),
-            Some(&input.requested_model),
-        )
-        .await
-    {
-        crate::ai_serving::apply_model_directive_mapping_patch(
-            &mut provider_request_body,
-            &mapping,
-        );
-        // Directive mapping is a deep-merge patch and may overwrite/add `stream`;
-        // re-enforce stream-field policy afterward.
-        enforce_provider_body_stream_policy(
-            &mut provider_request_body,
-            provider_api_format.as_str(),
-            upstream_is_stream,
-            request_requires_body_stream_field(body_json, force_body_stream_field),
-        );
-    }
-    apply_deepseek_tool_call_thinking_compat(
+    if !finalize_openai_chat_provider_request_body(
         &mut provider_request_body,
-        transport.provider.provider_type.as_str(),
-        transport.endpoint.base_url.as_str(),
+        model_directive_mapping.as_ref(),
         provider_api_format.as_str(),
-        Some(body_json),
-    );
+        upstream_is_stream,
+        force_body_stream_field,
+        body_json,
+        transport,
+        &prepared_candidate.mapped_model,
+    ) {
+        mark_skipped_local_openai_chat_candidate_with_extra_data(
+            state,
+            input,
+            trace_id,
+            candidate,
+            candidate_index,
+            candidate_id,
+            "provider_request_body_build_failed",
+            request_conversion_failure_extra_data(
+                body_json,
+                "openai:chat",
+                provider_api_format.as_str(),
+                Some(prepared_candidate.mapped_model.as_str()),
+                Some(parts.uri.path()),
+                upstream_is_stream,
+                "openai_chat_request_conversion",
+            ),
+        )
+        .await;
+        return Ok(None);
+    }
 
     if let Some(kiro_auth) = kiro_auth.as_ref() {
         return Ok(build_kiro_openai_chat_cross_format_payload_parts(
@@ -845,7 +972,7 @@ pub(crate) async fn resolve_local_openai_chat_candidate_payload_parts(
         return Ok(None);
     };
     let mut provider_request_headers = resolved_headers.headers;
-    apply_codex_openai_responses_special_headers(
+    apply_codex_openai_special_headers(
         &mut provider_request_headers,
         &provider_request_body,
         effective_headers,
@@ -997,7 +1124,7 @@ async fn build_antigravity_openai_chat_cross_format_payload_parts(
             }
         };
     let mut provider_request_headers = resolved.headers.headers;
-    apply_codex_openai_responses_special_headers(
+    apply_codex_openai_special_headers(
         &mut provider_request_headers,
         &resolved.body,
         effective_headers,
@@ -1148,7 +1275,7 @@ async fn build_gemini_cli_openai_chat_cross_format_payload_parts(
             }
         };
     let mut provider_request_headers = resolved.headers.headers;
-    apply_codex_openai_responses_special_headers(
+    apply_codex_openai_special_headers(
         &mut provider_request_headers,
         &resolved.body,
         effective_headers,
@@ -1255,6 +1382,19 @@ async fn resolve_openai_chat_to_openai_image_payload_parts(
         .provider_type
         .trim()
         .eq_ignore_ascii_case("chatgpt_web");
+    let is_codex = transport
+        .provider
+        .provider_type
+        .trim()
+        .eq_ignore_ascii_case("codex");
+    let upstream_is_stream =
+        crate::ai_serving::planner::common::resolve_upstream_is_stream_for_provider(
+            transport.endpoint.config.as_ref(),
+            transport.provider.provider_type.as_str(),
+            provider_api_format,
+            upstream_is_stream,
+            false,
+        );
     let Some((mut provider_request_body, image_request_summary)) = (if is_chatgpt_web {
         build_chatgpt_web_image_provider_body_from_openai_chat_body(
             body_json,
@@ -1263,7 +1403,7 @@ async fn resolve_openai_chat_to_openai_image_payload_parts(
     } else {
         build_openai_image_provider_body_from_openai_chat_body(
             body_json,
-            &input.requested_model,
+            &prepared_candidate.mapped_model,
             upstream_is_stream,
         )
     }) else {
@@ -1280,24 +1420,70 @@ async fn resolve_openai_chat_to_openai_image_payload_parts(
         .await;
         return Ok(None);
     };
+    let Some(operation) = openai_image_operation_from_summary(&image_request_summary) else {
+        return Ok(None);
+    };
     if !is_chatgpt_web {
-        apply_codex_openai_responses_special_body_edits(
-            &mut provider_request_body,
-            transport.provider.provider_type.as_str(),
-            provider_api_format,
-            transport.endpoint.body_rules.as_ref(),
-            Some(candidate.key_id.as_str()),
-        );
+        let Some(projected) = project_openai_image_api_request_body(
+            &provider_request_body,
+            &prepared_candidate.mapped_model,
+            operation,
+            crate::image_capabilities::openai_image_provider_max_generation_count_for_model(
+                transport.provider.provider_type.as_str(),
+                Some(prepared_candidate.mapped_model.as_str()),
+            ),
+        ) else {
+            mark_skipped_local_openai_chat_candidate_with_extra_data(
+                state,
+                input,
+                trace_id,
+                candidate,
+                candidate_index,
+                candidate_id,
+                "provider_request_body_build_failed",
+                request_body_build_failure_extra_data(
+                    body_json,
+                    "openai:chat",
+                    provider_api_format,
+                ),
+            )
+            .await;
+            return Ok(None);
+        };
+        provider_request_body = projected;
+    }
+    if is_codex {
+        let Some(projected) =
+            project_codex_openai_image_api_request_body(&provider_request_body, operation)
+        else {
+            mark_skipped_local_openai_chat_candidate_with_extra_data(
+                state,
+                input,
+                trace_id,
+                candidate,
+                candidate_index,
+                candidate_id,
+                "provider_request_body_build_failed",
+                request_body_build_failure_extra_data(
+                    body_json,
+                    "openai:chat",
+                    provider_api_format,
+                ),
+            )
+            .await;
+            return Ok(None);
+        };
+        provider_request_body = projected;
     }
 
     let upstream_url = if is_chatgpt_web {
         chatgpt_web_image_internal_url(&transport.endpoint.base_url)
     } else {
-        build_openai_image_upstream_url(
-            transport,
-            Some("/v1/images/generations"),
-            parts.uri.query(),
-        )
+        let request_path = match operation {
+            OpenAiImageOperation::Generate => "/v1/images/generations",
+            OpenAiImageOperation::Edit => "/v1/images/edits",
+        };
+        build_openai_image_upstream_url(transport, Some(request_path), parts.uri.query())
     };
     let Some(mut provider_request_headers) =
         build_openai_image_headers(ProviderOpenAiImageHeadersInput {
@@ -1305,7 +1491,13 @@ async fn resolve_openai_chat_to_openai_image_payload_parts(
             headers: &parts.headers,
             auth_header: &prepared_candidate.auth_header,
             auth_value: &prepared_candidate.auth_value,
-            accept: "text/event-stream",
+            accept: if is_codex {
+                None
+            } else if upstream_is_stream {
+                Some("text/event-stream")
+            } else {
+                Some("application/json")
+            },
             header_rules: transport.endpoint.header_rules.as_ref(),
             provider_request_body: &provider_request_body,
             original_request_body: body_json,
@@ -1331,7 +1523,7 @@ async fn resolve_openai_chat_to_openai_image_payload_parts(
     if is_chatgpt_web {
         provider_request_headers.insert("x-aether-chatgpt-web-image".to_string(), "1".to_string());
     } else {
-        apply_codex_openai_responses_special_headers(
+        apply_codex_openai_special_headers(
             &mut provider_request_headers,
             &provider_request_body,
             &parts.headers,
@@ -1386,46 +1578,24 @@ fn build_openai_image_provider_body_from_openai_chat_body(
     copy_openai_chat_image_option(body_json, &mut image_options, "input_fidelity");
     copy_openai_chat_image_option(body_json, &mut image_options, "partial_images");
 
-    let input = if images.is_empty() {
-        serde_json::json!([{
-            "role": "user",
-            "content": prompt,
-        }])
-    } else {
-        let mut content = vec![serde_json::json!({
-            "type": "input_text",
-            "text": prompt,
-        })];
-        content.extend(images);
-        serde_json::json!([{
-            "role": "user",
-            "content": content,
-        }])
-    };
-
     let mut body = serde_json::Map::new();
-    if let Some(model) = body_json
-        .get("model")
-        .and_then(Value::as_str)
-        .map(str::trim)
-        .filter(|value| !value.is_empty())
-        .or_else(|| {
-            let requested_model = requested_model.trim();
-            (!requested_model.is_empty()).then_some(requested_model)
-        })
-    {
-        body.insert("model".to_string(), Value::String(model.to_string()));
+    let requested_model = requested_model.trim();
+    if requested_model.is_empty() {
+        return None;
     }
-    body.insert("input".to_string(), input);
-    let mut image_tool = image_options.clone();
-    image_tool.insert(
-        "type".to_string(),
-        Value::String("image_generation".to_string()),
-    );
     body.insert(
-        "tools".to_string(),
-        Value::Array(vec![Value::Object(image_tool)]),
+        "model".to_string(),
+        Value::String(requested_model.to_string()),
     );
+    body.insert("prompt".to_string(), Value::String(prompt));
+    body.extend(image_options.clone());
+    if operation == "edit" {
+        let image_urls = openai_image_inputs_as_api_urls(&images);
+        if image_urls.len() != images.len() {
+            return None;
+        }
+        body.insert("images".to_string(), Value::Array(image_urls));
+    }
     if upstream_is_stream {
         body.insert("stream".to_string(), Value::Bool(true));
     }
@@ -1451,6 +1621,14 @@ fn build_openai_image_provider_body_from_openai_chat_body(
     Some((Value::Object(body), Value::Object(summary)))
 }
 
+fn openai_image_operation_from_summary(summary: &Value) -> Option<OpenAiImageOperation> {
+    match summary.get("operation")?.as_str()? {
+        "generate" => Some(OpenAiImageOperation::Generate),
+        "edit" => Some(OpenAiImageOperation::Edit),
+        _ => None,
+    }
+}
+
 fn build_chatgpt_web_image_provider_body_from_openai_chat_body(
     body_json: &Value,
     requested_model: &str,
@@ -1603,6 +1781,20 @@ fn openai_image_inputs_as_urls(images: &[Value]) -> Vec<Value> {
         .collect()
 }
 
+fn openai_image_inputs_as_api_urls(images: &[Value]) -> Vec<Value> {
+    images
+        .iter()
+        .filter_map(|image| {
+            image
+                .get("image_url")
+                .and_then(Value::as_str)
+                .map(str::trim)
+                .filter(|value| !value.is_empty())
+                .map(|value| json!({ "image_url": value }))
+        })
+        .collect()
+}
+
 fn chatgpt_web_ratio_for_size(size: &str) -> String {
     let Some((width, height)) = size.split_once('x') else {
         return "1:1".to_string();
@@ -2011,6 +2203,7 @@ mod tests {
             routing_policy: None,
             routing_trace_seed: None,
             routing_context: None,
+            model_directive_policy: Default::default(),
         }
     }
 
@@ -2096,6 +2289,7 @@ mod tests {
                 global_model_id: "global-model-1".to_string(),
                 global_model_name: "gemini-2.5-pro".to_string(),
                 selected_provider_model_name: "gemini-2.5-pro".to_string(),
+                supports_streaming: true,
                 mapping_matched_model: None,
             },
             transport: Arc::new(sample_gemini_cli_transport()),
@@ -2138,6 +2332,238 @@ mod tests {
         eligible
     }
 
+    fn sample_openai_chat_eligible(provider_type: &str) -> EligibleLocalExecutionCandidate {
+        let mut transport = sample_gemini_cli_transport();
+        transport.provider.name = provider_type.to_string();
+        transport.provider.provider_type = provider_type.to_string();
+        transport.endpoint.api_format = "openai:chat".to_string();
+        transport.endpoint.api_family = Some("openai".to_string());
+        transport.endpoint.endpoint_kind = Some("chat_completions".to_string());
+        transport.endpoint.base_url = if provider_type == "grok" {
+            "https://grok.com".to_string()
+        } else {
+            "https://api.openai.test".to_string()
+        };
+        transport.endpoint.custom_path = None;
+        transport.key.api_formats = Some(vec!["openai:chat".to_string()]);
+        transport.key.upstream_metadata = None;
+        if provider_type == "grok" {
+            transport.key.auth_type = "oauth".to_string();
+            transport.key.decrypted_api_key.clear();
+            transport.key.decrypted_auth_config =
+                Some(json!({ "sso_token": "test-session" }).to_string());
+        } else {
+            transport.key.auth_type = "bearer".to_string();
+            transport.key.decrypted_api_key = "test-api-key".to_string();
+            transport.key.decrypted_auth_config = None;
+        }
+
+        let mut eligible = sample_gemini_cli_eligible();
+        eligible.candidate.provider_name = provider_type.to_string();
+        eligible.candidate.provider_type = provider_type.to_string();
+        eligible.candidate.endpoint_api_format = "openai:chat".to_string();
+        eligible.candidate.global_model_name = "gpt-5.6-sol".to_string();
+        eligible.candidate.selected_provider_model_name = "gpt-5.6-sol".to_string();
+        eligible.transport = Arc::new(transport);
+        eligible.provider_api_format = "openai:chat".to_string();
+        eligible
+    }
+
+    fn sample_custom_directive_input() -> LocalOpenAiChatDecisionInput {
+        let mut input = sample_input();
+        input.requested_model = "gpt-5.6-sol-high".to_string();
+        input.model_directive_policy =
+            crate::system_features::ModelDirectivePolicySnapshot::from_config_values(
+                Some(&json!(true)),
+                Some(&json!({
+                    "reasoning_effort": {
+                        "api_formats": {
+                            "openai:chat": {
+                                "suffixes": ["high"],
+                                "mappings": {
+                                    "high": {
+                                        "reasoning_effort": "low",
+                                        "stream": false
+                                    }
+                                }
+                            }
+                        }
+                    }
+                })),
+            );
+        input
+    }
+
+    fn sample_alias_max_directive_input() -> LocalOpenAiChatDecisionInput {
+        let mut input = sample_input();
+        input.requested_model = "deployment-alias-max".to_string();
+        input.model_directive_policy =
+            crate::system_features::ModelDirectivePolicySnapshot::from_config_values(
+                Some(&json!(true)),
+                None,
+            );
+        input
+    }
+
+    #[tokio::test]
+    async fn alias_reasoning_directive_is_constrained_by_the_mapped_openai_model() {
+        let state = AppState::new().expect("state should build");
+        let request = http::Request::builder()
+            .method("POST")
+            .uri("/v1/chat/completions")
+            .header(http::header::CONTENT_TYPE, "application/json")
+            .body(())
+            .expect("request should build");
+        let (parts, _) = request.into_parts();
+        let body_json = json!({
+            "model": "deployment-alias-max",
+            "messages": [{"role": "user", "content": "hello"}]
+        });
+
+        let mut supported = sample_openai_chat_eligible("custom");
+        supported.candidate.selected_provider_model_name = "gpt-5.6-sol".to_string();
+        let payload = resolve_local_openai_chat_candidate_payload_parts(
+            &state,
+            &parts,
+            "trace-alias-max-gpt-5.6-sol",
+            &body_json,
+            &sample_alias_max_directive_input(),
+            None,
+            &supported,
+            0,
+            "candidate-0",
+            "openai_chat_sync",
+            "openai_chat_sync_success",
+            false,
+        )
+        .await
+        .expect("candidate resolution should not fail")
+        .expect("GPT-5.6 candidate should build a payload");
+        assert_eq!(payload.provider_request_body["reasoning_effort"], "max");
+
+        let mut unsupported = sample_openai_chat_eligible("custom");
+        unsupported.candidate.selected_provider_model_name = "gpt-5.4".to_string();
+        let payload = resolve_local_openai_chat_candidate_payload_parts(
+            &state,
+            &parts,
+            "trace-alias-max-gpt-5.4",
+            &body_json,
+            &sample_alias_max_directive_input(),
+            None,
+            &unsupported,
+            0,
+            "candidate-0",
+            "openai_chat_sync",
+            "openai_chat_sync_success",
+            false,
+        )
+        .await
+        .expect("candidate resolution should not fail");
+        assert!(payload.is_none(), "GPT-5.4 must reject the max directive");
+    }
+
+    #[tokio::test]
+    async fn custom_policy_suffix_patch_is_applied_after_candidate_mapping() {
+        let state = AppState::new().expect("state should build");
+        let request = http::Request::builder()
+            .method("POST")
+            .uri("/v1/chat/completions")
+            .header(http::header::CONTENT_TYPE, "application/json")
+            .body(())
+            .expect("request should build");
+        let (parts, _) = request.into_parts();
+        let body_json = json!({
+            "model": "deployment-alias-VendorFuture",
+            "messages": [{"role": "user", "content": "hello"}]
+        });
+        let mut input = sample_input();
+        input.requested_model = "deployment-alias-VendorFuture".to_string();
+        input.model_directive_policy =
+            crate::system_features::ModelDirectivePolicySnapshot::from_config_values(
+                Some(&json!(true)),
+                Some(&json!({
+                    "reasoning_effort": {
+                        "api_formats": {
+                            "openai:chat": {
+                                "suffixes": ["VendorFuture"],
+                                "mappings": {
+                                    "VendorFuture": {
+                                        "reasoning_effort": "high"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                })),
+            );
+        let payload = resolve_local_openai_chat_candidate_payload_parts(
+            &state,
+            &parts,
+            "trace-custom-policy-suffix",
+            &body_json,
+            &input,
+            None,
+            &sample_openai_chat_eligible("custom"),
+            0,
+            "candidate-0",
+            "openai_chat_sync",
+            "openai_chat_sync_success",
+            false,
+        )
+        .await
+        .expect("candidate resolution should not fail")
+        .expect("custom directive candidate should build a payload");
+
+        assert_eq!(payload.provider_request_body["model"], "gpt-5.6-sol");
+        assert_eq!(payload.provider_request_body["reasoning_effort"], "high");
+    }
+
+    #[tokio::test]
+    async fn same_format_and_grok_chat_apply_the_same_custom_directive_finalization() {
+        let state = AppState::new().expect("state should build");
+        let request = http::Request::builder()
+            .method("POST")
+            .uri("/v1/chat/completions")
+            .header(http::header::CONTENT_TYPE, "application/json")
+            .body(())
+            .expect("request should build");
+        let (parts, _) = request.into_parts();
+        let body_json = json!({
+            "model": "gpt-5.6-sol-high",
+            "messages": [{"role": "user", "content": "hello"}],
+            "stream": true
+        });
+
+        for provider_type in ["custom", "grok"] {
+            let payload = resolve_local_openai_chat_candidate_payload_parts(
+                &state,
+                &parts,
+                &format!("trace-directive-{provider_type}"),
+                &body_json,
+                &sample_custom_directive_input(),
+                None,
+                &sample_openai_chat_eligible(provider_type),
+                0,
+                "candidate-0",
+                OPENAI_CHAT_STREAM_PLAN_KIND,
+                "openai_chat_stream_success",
+                true,
+            )
+            .await
+            .expect("candidate resolution should not fail")
+            .expect("same-format candidate should build a payload");
+
+            assert_eq!(
+                payload.provider_request_body["reasoning_effort"], "low",
+                "custom mapping must be authoritative for {provider_type}"
+            );
+            assert_eq!(
+                payload.provider_request_body["stream"], true,
+                "stream policy must be re-applied after mapping for {provider_type}"
+            );
+        }
+    }
+
     #[tokio::test]
     async fn openai_chat_to_gemini_cli_wraps_cross_format_body_in_v1internal_envelope() {
         let state = AppState::new().expect("state should build");
@@ -2333,7 +2759,7 @@ mod tests {
     }
 
     #[test]
-    fn openai_chat_image_bridge_body_injects_image_generation_tool() {
+    fn openai_chat_image_bridge_builds_images_api_body() {
         let body_json = json!({
             "model": "gpt-image-2",
             "messages": [
@@ -2347,13 +2773,22 @@ mod tests {
             build_openai_image_provider_body_from_openai_chat_body(&body_json, "gpt-image-2", true)
                 .expect("chat image body should convert");
 
-        assert_eq!(provider_body["tools"][0]["type"], "image_generation");
-        assert_eq!(provider_body["tools"][0]["size"], "1024x1024");
-        assert_eq!(provider_body["tools"][0]["output_format"], "png");
         assert_eq!(provider_body["model"], "gpt-image-2");
+        assert_eq!(provider_body["prompt"], "Draw a glass city");
+        assert_eq!(provider_body["size"], "1024x1024");
+        assert_eq!(provider_body["output_format"], "png");
         assert_eq!(provider_body["stream"], true);
-        assert_eq!(provider_body["input"][0]["content"], "Draw a glass city");
+        assert!(provider_body.get("tools").is_none());
+        assert!(provider_body.get("input").is_none());
         assert_eq!(summary["operation"], "generate");
         assert_eq!(summary["output_format"], "png");
+
+        let (sync_provider_body, _) = build_openai_image_provider_body_from_openai_chat_body(
+            &body_json,
+            "gpt-image-2",
+            false,
+        )
+        .expect("chat image body should convert for a sync upstream");
+        assert!(sync_provider_body.get("stream").is_none());
     }
 }

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

@@ -293,9 +293,11 @@ pub(crate) async fn build_lazy_local_openai_chat_candidate_attempt_source<'a>(
     );
     build_lazy_requested_model_execution_candidate_attempt_source_with_serving(
         planner_state,
+        &input.model_directive_policy,
         trace_id,
         "openai:chat",
         &input.requested_model,
+        None,
         require_streaming,
         &input.auth_snapshot,
         input.client_session_affinity.as_ref(),

apps/aether-gateway/src/ai_serving/planner/standard/openai/chat/plans/candidates.rs

@@ -21,8 +21,10 @@ pub(crate) async fn list_local_openai_chat_candidates(
 > {
     let outcome = preselect_local_execution_candidates_with_serving(
         PlannerAppState::new(state),
+        &input.model_directive_policy,
         "openai:chat",
         &input.requested_model,
+        None,
         require_streaming,
         input.required_capabilities.as_ref(),
         &input.auth_snapshot,

apps/aether-gateway/src/ai_serving/planner/standard/openai/chat/plans/resolve.rs

@@ -65,7 +65,9 @@ pub(crate) async fn resolve_local_openai_chat_decision_input(
         state,
         auth_context.clone(),
         Some(requested_model.as_str()),
+        decision.auth_endpoint_signature.as_deref(),
         None,
+        &decision.model_directive_policy,
     )
     .await
     {

apps/aether-gateway/src/ai_serving/planner/standard/openai/chat/plans/stream.rs

@@ -111,7 +111,7 @@ pub(crate) async fn build_local_openai_chat_stream_attempt_source<'a>(
             input,
             candidates,
             prefetched_attempts: VecDeque::new(),
-            request_preparation: LocalOpenAiChatRequestPreparation::default(),
+            request_preparation: LocalOpenAiChatRequestPreparation,
         },
         candidate_count,
     )))

apps/aether-gateway/src/ai_serving/planner/standard/openai/plan_builders/stream.rs

@@ -129,7 +129,7 @@ pub(crate) fn build_openai_chat_stream_plan_from_decision(
             headers: std::mem::take(&mut provider_request_headers),
             content_type,
             body: RequestBody::from_json(provider_request_body_value),
-            stream: true,
+            stream: effective_upstream_is_stream,
         },
     );
 
@@ -229,7 +229,7 @@ pub(crate) fn build_openai_responses_stream_plan_from_decision(
             headers: std::mem::take(&mut provider_request_headers),
             content_type,
             body: RequestBody::from_json(provider_request_body_value),
-            stream: true,
+            stream: effective_upstream_is_stream,
         },
     );
 
@@ -291,6 +291,7 @@ mod tests {
             request_id: Some("req_123".to_string()),
             candidate_id: Some("cand_123".to_string()),
             provider_name: Some("Codex".to_string()),
+            provider_type: Some("codex".to_string()),
             provider_id: Some("prov_123".to_string()),
             endpoint_id: Some("ep_123".to_string()),
             key_id: Some("key_123".to_string()),
@@ -385,6 +386,46 @@ mod tests {
         );
     }
 
+    #[test]
+    fn build_compact_stream_plan_preserves_non_stream_upstream_mode() {
+        let parts = http::Request::builder()
+            .uri("http://localhost/v1/responses/compact")
+            .body(())
+            .expect("request should build")
+            .into_parts()
+            .0;
+        let mut payload = sample_responses_payload();
+        payload.decision_kind = Some("openai_responses_compact_stream".to_string());
+        payload.upstream_url = Some("https://example.com/v1/responses/compact".to_string());
+        payload.provider_api_format = Some("openai:responses:compact".to_string());
+        payload.client_api_format = Some("openai:responses:compact".to_string());
+        payload.upstream_is_stream = false;
+        payload.provider_request_body = Some(json!({
+            "model": "gpt-5.6-sol",
+            "input": [],
+            "instructions": "You are Codex.",
+            "tools": [],
+            "parallel_tool_calls": true,
+            "reasoning": {"effort": "high"},
+            "prompt_cache_key": "cache-key",
+            "text": {"verbosity": "low"}
+        }));
+
+        let built =
+            build_openai_responses_stream_plan_from_decision(&parts, &json!({}), payload, true)
+                .expect("plan build should succeed")
+                .expect("plan should be produced");
+
+        assert!(!built.plan.stream);
+        assert!(built
+            .plan
+            .body
+            .json_body
+            .as_ref()
+            .is_some_and(|body| body.get("stream").is_none()));
+        assert!(!built.plan.headers.contains_key("accept"));
+    }
+
     #[test]
     fn build_openai_chat_stream_plan_fallback_preserves_complete_same_format_headers() {
         let parts = http::Request::builder()
@@ -404,6 +445,7 @@ mod tests {
             request_id: Some("req_stream_456".to_string()),
             candidate_id: Some("cand_stream_456".to_string()),
             provider_name: Some("OpenAI".to_string()),
+            provider_type: Some("openai".to_string()),
             provider_id: Some("prov_stream_456".to_string()),
             endpoint_id: Some("ep_stream_456".to_string()),
             key_id: Some("key_stream_456".to_string()),
@@ -462,7 +504,7 @@ mod tests {
     }
 
     #[test]
-    fn build_openai_chat_stream_plan_keeps_downstream_stream_for_force_non_stream_upstream() {
+    fn build_openai_chat_stream_plan_preserves_force_non_stream_upstream_mode() {
         fn force_non_stream_payload(provider_request_body: Option<Value>) -> AiExecutionDecision {
             AiExecutionDecision {
                 action: "stream".to_string(),
@@ -472,6 +514,7 @@ mod tests {
                 request_id: Some("req_force_non_stream".to_string()),
                 candidate_id: Some("cand_force_non_stream".to_string()),
                 provider_name: Some("OpenAI".to_string()),
+                provider_type: Some("openai".to_string()),
                 provider_id: Some("prov_force_non_stream".to_string()),
                 endpoint_id: Some("ep_force_non_stream".to_string()),
                 key_id: Some("key_force_non_stream".to_string()),
@@ -523,7 +566,7 @@ mod tests {
         .expect("plan build should succeed")
         .expect("plan should be produced");
 
-        assert!(built.plan.stream);
+        assert!(!built.plan.stream);
         assert_eq!(
             built
                 .plan
@@ -548,7 +591,7 @@ mod tests {
         .expect("fallback plan build should succeed")
         .expect("fallback plan should be produced");
 
-        assert!(built.plan.stream);
+        assert!(!built.plan.stream);
         assert_eq!(
             built
                 .plan
@@ -579,6 +622,7 @@ mod tests {
             request_id: Some("req_stream_789".to_string()),
             candidate_id: Some("cand_stream_789".to_string()),
             provider_name: Some("Claude".to_string()),
+            provider_type: Some("anthropic".to_string()),
             provider_id: Some("prov_stream_789".to_string()),
             endpoint_id: Some("ep_stream_789".to_string()),
             key_id: Some("key_stream_789".to_string()),

apps/aether-gateway/src/ai_serving/planner/standard/openai/plan_builders/sync.rs

@@ -257,6 +257,7 @@ mod tests {
             request_id: Some("req_123".to_string()),
             candidate_id: Some("cand_123".to_string()),
             provider_name: Some("Codex".to_string()),
+            provider_type: Some("codex".to_string()),
             provider_id: Some("prov_123".to_string()),
             endpoint_id: Some("ep_123".to_string()),
             key_id: Some("key_123".to_string()),
@@ -369,6 +370,7 @@ mod tests {
             request_id: Some("req_456".to_string()),
             candidate_id: Some("cand_456".to_string()),
             provider_name: Some("OpenAI".to_string()),
+            provider_type: Some("openai".to_string()),
             provider_id: Some("prov_456".to_string()),
             endpoint_id: Some("ep_456".to_string()),
             key_id: Some("key_456".to_string()),
@@ -440,6 +442,7 @@ mod tests {
             request_id: Some("req_789".to_string()),
             candidate_id: Some("cand_789".to_string()),
             provider_name: Some("Claude".to_string()),
+            provider_type: Some("anthropic".to_string()),
             provider_id: Some("prov_789".to_string()),
             endpoint_id: Some("ep_789".to_string()),
             key_id: Some("key_789".to_string()),

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

@@ -9,7 +9,7 @@ use crate::ai_serving::planner::report_context::{
 };
 use crate::ai_serving::planner::spec_metadata::local_openai_responses_spec_metadata;
 use crate::ai_serving::planner::{
-    build_ai_execution_decision_response, resolve_transport_request_gzip_policy,
+    build_ai_execution_decision_response, resolve_transport_request_encoding_policy,
     AiExecutionDecisionResponseParts,
 };
 use crate::ai_serving::transport::{
@@ -204,7 +204,7 @@ pub(crate) async fn maybe_build_local_openai_responses_decision_payload_for_cand
         image_request_summary: _,
         request_redacted: _,
     } = resolved;
-    let request_gzip = resolve_transport_request_gzip_policy(&transport);
+    let request_encoding = resolve_transport_request_encoding_policy(&transport);
 
     let mut decision = build_ai_execution_decision_response(AiExecutionDecisionResponseParts {
         decision_is_stream: spec_metadata.require_streaming,
@@ -214,6 +214,7 @@ pub(crate) async fn maybe_build_local_openai_responses_decision_payload_for_cand
         request_id: trace_id.to_string(),
         candidate_id: candidate_id.clone(),
         provider_name: transport.provider.name.clone(),
+        provider_type: transport.provider.provider_type.clone(),
         provider_id: candidate.provider_id.clone(),
         endpoint_id: candidate.endpoint_id.clone(),
         key_id: candidate.key_id.clone(),
@@ -231,8 +232,8 @@ pub(crate) async fn maybe_build_local_openai_responses_decision_payload_for_cand
         provider_request_body: Some(provider_request_body),
         provider_request_body_base64: None,
         content_type: Some("application/json".to_string()),
-        content_encoding: None,
-        request_gzip,
+        content_encoding: request_encoding.content_encoding,
+        request_gzip: request_encoding.request_gzip,
         proxy,
         transport_profile,
         timeouts,
@@ -241,6 +242,10 @@ pub(crate) async fn maybe_build_local_openai_responses_decision_payload_for_cand
         report_context: Some(report_context),
         auth_context: input.auth_context.clone(),
     });
-    apply_provider_request_routing_policy_to_decision(input, &mut decision)?;
+    apply_provider_request_routing_policy_to_decision(
+        input,
+        &mut decision,
+        Some(transport.as_ref()),
+    )?;
     Ok(Some(decision))
 }

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

@@ -27,11 +27,12 @@ use crate::ai_serving::planner::redaction::{
 };
 use crate::ai_serving::planner::spec_metadata::local_openai_responses_spec_metadata;
 use crate::ai_serving::planner::standard::{
-    apply_codex_openai_responses_special_body_edits, apply_codex_openai_responses_special_headers,
-    apply_deepseek_tool_call_thinking_compat, build_cross_format_openai_responses_request_body,
-    build_cross_format_openai_responses_upstream_url, build_local_openai_responses_request_body,
-    build_local_openai_responses_upstream_url, request_body_build_failure_extra_data,
-    request_conversion_failure_extra_data,
+    apply_codex_openai_special_headers, apply_deepseek_tool_call_thinking_compat,
+    build_cross_format_openai_responses_request_body_with_codex_model_capabilities,
+    build_cross_format_openai_responses_upstream_url,
+    build_local_openai_responses_request_body_with_codex_model_capabilities,
+    build_local_openai_responses_upstream_url, codex_model_capabilities_for_transport,
+    request_body_build_failure_extra_data, request_conversion_failure_extra_data,
 };
 use crate::ai_serving::transport::antigravity::is_antigravity_provider_transport;
 use crate::ai_serving::transport::auth::{
@@ -58,7 +59,10 @@ use crate::ai_serving::transport::{
 use crate::ai_serving::{
     ai_local_execution_contract_for_formats, request_conversion_direct_auth,
     request_conversion_kind, CandidateFailureDiagnostic, GatewayProviderTransportSnapshot,
-    LocalResolvedOAuthRequestAuth, PlannerAppState,
+    LocalResolvedOAuthRequestAuth, OpenAiImageOperation, PlannerAppState,
+};
+use crate::ai_serving::{
+    project_codex_openai_image_api_request_body, project_openai_image_api_request_body,
 };
 use crate::ai_serving::{ConversionMode, ExecutionStrategy};
 use crate::{AppState, GatewayError};
@@ -282,13 +286,26 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
     let auth_header = prepared_candidate.auth_header;
     let auth_value = prepared_candidate.auth_value;
     let mapped_model = prepared_candidate.mapped_model;
-    let enable_model_directives =
-        crate::system_features::reasoning_model_directive_enabled_for_api_format_and_model(
-            state,
-            provider_api_format,
-            Some(&input.requested_model),
-        )
-        .await;
+    let model_directive_resolution = input
+        .model_directive_policy
+        .resolve_reasoning(provider_api_format, Some(&input.requested_model));
+    let model_directive_mapping =
+        match model_directive_resolution.mapping_patch_for_mapped_model(&mapped_model) {
+            Ok(mapping) => mapping,
+            Err(skip_reason) => {
+                mark_skipped_local_openai_responses_candidate(
+                    state,
+                    input,
+                    trace_id,
+                    candidate,
+                    candidate_index,
+                    candidate_id,
+                    skip_reason,
+                )
+                .await;
+                return Ok(None);
+            }
+        };
     let redaction = resolve_provider_chat_pii_redaction(
         state,
         parts,
@@ -311,9 +328,19 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
     let force_body_stream_field =
         endpoint_config_forces_body_stream_field(transport.endpoint.config.as_ref());
     let effective_headers = input.effective_headers(&parts.headers);
+    let source_model = body_json
+        .get("model")
+        .and_then(Value::as_str)
+        .unwrap_or(input.requested_model.as_str());
+    let codex_model_capabilities = codex_model_capabilities_for_transport(
+        &transport,
+        provider_api_format,
+        mapped_model.as_str(),
+        source_model,
+    );
     let Some(mut base_provider_request_body) =
         (if is_grok && is_grok_text_provider_api_format(provider_api_format) {
-            build_local_openai_responses_request_body(
+            build_local_openai_responses_request_body_with_codex_model_capabilities(
                 body_json,
                 &mapped_model,
                 upstream_is_stream,
@@ -321,12 +348,12 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
                 transport.provider.provider_type.as_str(),
                 spec_metadata.api_format,
                 transport.endpoint.body_rules.as_ref(),
-                Some(input.auth_context.api_key_id.as_str()),
                 effective_headers,
-                enable_model_directives,
+                codex_model_capabilities.as_ref(),
+                false,
             )
         } else if needs_bidirectional_conversion {
-            build_cross_format_openai_responses_request_body(
+            build_cross_format_openai_responses_request_body_with_codex_model_capabilities(
                 body_json,
                 &mapped_model,
                 spec_metadata.api_format,
@@ -339,12 +366,12 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
                 } else {
                     transport.endpoint.body_rules.as_ref()
                 },
-                Some(input.auth_context.api_key_id.as_str()),
                 effective_headers,
-                enable_model_directives,
+                codex_model_capabilities.as_ref(),
+                false,
             )
         } else {
-            build_local_openai_responses_request_body(
+            build_local_openai_responses_request_body_with_codex_model_capabilities(
                 body_json,
                 &mapped_model,
                 upstream_is_stream,
@@ -356,9 +383,9 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
                 } else {
                     transport.endpoint.body_rules.as_ref()
                 },
-                Some(input.auth_context.api_key_id.as_str()),
                 effective_headers,
-                enable_model_directives,
+                codex_model_capabilities.as_ref(),
+                false,
             )
         })
     else {
@@ -383,17 +410,10 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
         .await;
         return Ok(None);
     };
-    if let Some(mapping) =
-        crate::system_features::reasoning_model_directive_mapping_for_api_format_and_model(
-            state,
-            provider_api_format,
-            Some(&input.requested_model),
-        )
-        .await
-    {
+    if let Some(mapping) = model_directive_mapping.as_ref() {
         crate::ai_serving::apply_model_directive_mapping_patch(
             &mut base_provider_request_body,
-            &mapping,
+            mapping,
         );
         // Directive mapping is a deep-merge patch and may overwrite/add `stream`;
         // re-enforce stream-field policy afterward.
@@ -411,6 +431,46 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
         provider_api_format,
         Some(body_json),
     );
+    if crate::ai_serving::finalize_openai_provider_request_with_codex_model_capabilities(
+        &mut base_provider_request_body,
+        crate::ai_serving::OpenAiProviderRequestFinalization {
+            source_api_format: spec_metadata.api_format,
+            provider_api_format,
+            provider_type: transport.provider.provider_type.as_str(),
+            provider_model: mapped_model.as_str(),
+            source_model,
+            body_rules: transport.endpoint.body_rules.as_ref(),
+            upstream_is_stream,
+            require_body_stream_field: request_requires_body_stream_field(
+                body_json,
+                force_body_stream_field,
+            ),
+        },
+        codex_model_capabilities.as_ref(),
+    )
+    .is_err()
+    {
+        mark_skipped_local_openai_responses_candidate_with_extra_data(
+            state,
+            input,
+            trace_id,
+            candidate,
+            candidate_index,
+            candidate_id,
+            "provider_request_body_build_failed",
+            request_conversion_failure_extra_data(
+                body_json,
+                spec_metadata.api_format,
+                provider_api_format,
+                Some(mapped_model.as_str()),
+                Some(parts.uri.path()),
+                upstream_is_stream,
+                "openai_responses_request_conversion",
+            ),
+        )
+        .await;
+        return Ok(None);
+    }
     let provider_request_body = base_provider_request_body;
 
     if let Some(kiro_auth) = kiro_auth.as_ref() {
@@ -612,7 +672,11 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
     };
     let mut provider_request_headers = resolved_headers.headers;
     if !is_grok {
-        apply_codex_openai_responses_special_headers(
+        apply_local_auth_config_header_overrides(
+            &mut provider_request_headers,
+            transport.key.decrypted_auth_config.as_deref(),
+        );
+        apply_codex_openai_special_headers(
             &mut provider_request_headers,
             &provider_request_body,
             effective_headers,
@@ -621,9 +685,14 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
             Some(trace_id),
             transport.key.decrypted_auth_config.as_deref(),
         );
-        apply_local_auth_config_header_overrides(
+        crate::ai_serving::apply_codex_openai_responses_lite_header_for_request_body_with_capabilities(
             &mut provider_request_headers,
-            transport.key.decrypted_auth_config.as_deref(),
+            Some(&provider_request_body),
+            transport.provider.provider_type.as_str(),
+            provider_api_format,
+            mapped_model.as_str(),
+            source_model,
+            codex_model_capabilities.as_ref(),
         );
     }
     request_identity_response_encoding_when_redacted(
@@ -788,7 +857,11 @@ async fn build_antigravity_openai_responses_payload_parts(
             }
         };
     let mut provider_request_headers = resolved.headers.headers;
-    apply_codex_openai_responses_special_headers(
+    apply_local_auth_config_header_overrides(
+        &mut provider_request_headers,
+        resolved.transport.key.decrypted_auth_config.as_deref(),
+    );
+    apply_codex_openai_special_headers(
         &mut provider_request_headers,
         &resolved.body,
         effective_headers,
@@ -797,10 +870,6 @@ async fn build_antigravity_openai_responses_payload_parts(
         Some(trace_id),
         resolved.transport.key.decrypted_auth_config.as_deref(),
     );
-    apply_local_auth_config_header_overrides(
-        &mut provider_request_headers,
-        resolved.transport.key.decrypted_auth_config.as_deref(),
-    );
     provider_request_headers.insert("accept".to_string(), "text/event-stream".to_string());
     request_identity_response_encoding_when_redacted(
         &mut provider_request_headers,
@@ -941,7 +1010,11 @@ async fn build_gemini_cli_openai_responses_payload_parts(
             }
         };
     let mut provider_request_headers = resolved.headers.headers;
-    apply_codex_openai_responses_special_headers(
+    apply_local_auth_config_header_overrides(
+        &mut provider_request_headers,
+        resolved.transport.key.decrypted_auth_config.as_deref(),
+    );
+    apply_codex_openai_special_headers(
         &mut provider_request_headers,
         &resolved.body,
         effective_headers,
@@ -950,10 +1023,6 @@ async fn build_gemini_cli_openai_responses_payload_parts(
         Some(trace_id),
         resolved.transport.key.decrypted_auth_config.as_deref(),
     );
-    apply_local_auth_config_header_overrides(
-        &mut provider_request_headers,
-        resolved.transport.key.decrypted_auth_config.as_deref(),
-    );
     request_identity_response_encoding_when_redacted(
         &mut provider_request_headers,
         request_redacted,
@@ -1182,11 +1251,16 @@ async fn resolve_openai_responses_to_openai_image_payload_parts(
         .provider_type
         .trim()
         .eq_ignore_ascii_case("chatgpt_web");
+    let is_codex = transport
+        .provider
+        .provider_type
+        .trim()
+        .eq_ignore_ascii_case("codex");
     let upstream_is_stream = resolve_upstream_is_stream_for_provider(
         transport.endpoint.config.as_ref(),
         transport.provider.provider_type.as_str(),
         provider_api_format,
-        spec_metadata.require_streaming,
+        spec_metadata.require_streaming && candidate.supports_streaming,
         false,
     );
     let Some((mut provider_request_body, image_request_summary)) = (if is_chatgpt_web {
@@ -1197,7 +1271,7 @@ async fn resolve_openai_responses_to_openai_image_payload_parts(
     } else {
         build_openai_image_provider_body_from_openai_responses_body(
             body_json,
-            &input.requested_model,
+            &prepared_candidate.mapped_model,
             upstream_is_stream,
         )
     }) else {
@@ -1218,25 +1292,31 @@ async fn resolve_openai_responses_to_openai_image_payload_parts(
         .await;
         return None;
     };
-
+    let operation = openai_image_operation_from_summary(&image_request_summary)?;
     if !is_chatgpt_web {
-        apply_codex_openai_responses_special_body_edits(
-            &mut provider_request_body,
-            transport.provider.provider_type.as_str(),
-            provider_api_format,
-            transport.endpoint.body_rules.as_ref(),
-            Some(candidate.key_id.as_str()),
-        );
+        provider_request_body = project_openai_image_api_request_body(
+            &provider_request_body,
+            &prepared_candidate.mapped_model,
+            operation,
+            crate::image_capabilities::openai_image_provider_max_generation_count_for_model(
+                transport.provider.provider_type.as_str(),
+                Some(prepared_candidate.mapped_model.as_str()),
+            ),
+        )?;
+    }
+    if is_codex {
+        provider_request_body =
+            project_codex_openai_image_api_request_body(&provider_request_body, operation)?;
     }
 
     let upstream_url = if is_chatgpt_web {
         chatgpt_web_image_internal_url(&transport.endpoint.base_url)
     } else {
-        build_openai_image_upstream_url(
-            transport,
-            Some("/v1/images/generations"),
-            parts.uri.query(),
-        )
+        let request_path = match operation {
+            OpenAiImageOperation::Generate => "/v1/images/generations",
+            OpenAiImageOperation::Edit => "/v1/images/edits",
+        };
+        build_openai_image_upstream_url(transport, Some(request_path), parts.uri.query())
     };
     let Some(mut provider_request_headers) =
         build_openai_image_headers(ProviderOpenAiImageHeadersInput {
@@ -1244,7 +1324,13 @@ async fn resolve_openai_responses_to_openai_image_payload_parts(
             headers: &parts.headers,
             auth_header: &prepared_candidate.auth_header,
             auth_value: &prepared_candidate.auth_value,
-            accept: "text/event-stream",
+            accept: if is_codex {
+                None
+            } else if upstream_is_stream {
+                Some("text/event-stream")
+            } else {
+                Some("application/json")
+            },
             header_rules: transport.endpoint.header_rules.as_ref(),
             provider_request_body: &provider_request_body,
             original_request_body: body_json,
@@ -1270,7 +1356,11 @@ async fn resolve_openai_responses_to_openai_image_payload_parts(
     if is_chatgpt_web {
         provider_request_headers.insert("x-aether-chatgpt-web-image".to_string(), "1".to_string());
     } else {
-        apply_codex_openai_responses_special_headers(
+        apply_local_auth_config_header_overrides(
+            &mut provider_request_headers,
+            transport.key.decrypted_auth_config.as_deref(),
+        );
+        apply_codex_openai_special_headers(
             &mut provider_request_headers,
             &provider_request_body,
             &parts.headers,
@@ -1279,10 +1369,6 @@ async fn resolve_openai_responses_to_openai_image_payload_parts(
             Some(trace_id),
             transport.key.decrypted_auth_config.as_deref(),
         );
-        apply_local_auth_config_header_overrides(
-            &mut provider_request_headers,
-            transport.key.decrypted_auth_config.as_deref(),
-        );
     }
 
     let (execution_strategy, conversion_mode) =
@@ -1314,59 +1400,68 @@ fn build_openai_image_provider_body_from_openai_responses_body(
     upstream_is_stream: bool,
 ) -> Option<(Value, Value)> {
     let object = body_json.as_object()?;
-    let input = object.get("input")?.clone();
     let tool = openai_responses_image_generation_tool(object);
+    let (prompt, images) = collect_openai_responses_image_prompt_and_images(object.get("input"))?;
+    let operation = if images.is_empty() {
+        OpenAiImageOperation::Generate
+    } else {
+        OpenAiImageOperation::Edit
+    };
+    if let Some(action) = tool
+        .as_ref()
+        .and_then(|tool| tool.get("action"))
+        .and_then(Value::as_str)
+    {
+        let expected = operation.as_str();
+        if !action.trim().eq_ignore_ascii_case(expected) {
+            return None;
+        }
+    }
 
     let mut body = serde_json::Map::new();
-    body.insert("input".to_string(), input);
-    if let Some(model) = object
-        .get("model")
-        .and_then(Value::as_str)
-        .map(str::trim)
-        .filter(|value| !value.is_empty())
-        .or_else(|| {
-            let requested_model = requested_model.trim();
-            (!requested_model.is_empty()).then_some(requested_model)
-        })
-    {
-        body.insert("model".to_string(), Value::String(model.to_string()));
+    let requested_model = requested_model.trim();
+    if requested_model.is_empty() {
+        return None;
     }
+    body.insert(
+        "model".to_string(),
+        Value::String(requested_model.to_string()),
+    );
+    body.insert("prompt".to_string(), Value::String(prompt));
     for key in [
+        "background",
+        "quality",
+        "size",
+        "output_format",
+        "output_compression",
+        "moderation",
+        "input_fidelity",
+        "partial_images",
+        "n",
         "user",
-        "metadata",
-        "include",
-        "parallel_tool_calls",
-        "store",
     ] {
-        if let Some(value) = object.get(key) {
+        if let Some(value) = tool
+            .as_ref()
+            .and_then(|tool| tool.get(key))
+            .or_else(|| object.get(key))
+        {
             body.insert(key.to_string(), value.clone());
         }
     }
+    if operation == OpenAiImageOperation::Edit {
+        let image_urls = openai_image_inputs_as_api_urls(&images);
+        if image_urls.len() != images.len() {
+            return None;
+        }
+        body.insert("images".to_string(), Value::Array(image_urls));
+    }
     if upstream_is_stream {
         body.insert("stream".to_string(), Value::Bool(true));
-    } else if let Some(value) = object.get("stream") {
-        body.insert("stream".to_string(), value.clone());
     }
-    let image_tool = tool.clone().unwrap_or_else(|| {
-        let mut tool = serde_json::Map::new();
-        tool.insert(
-            "type".to_string(),
-            Value::String("image_generation".to_string()),
-        );
-        tool
-    });
-    body.insert(
-        "tools".to_string(),
-        Value::Array(vec![Value::Object(image_tool)]),
-    );
-
     let mut summary = serde_json::Map::new();
     summary.insert(
         "operation".to_string(),
-        tool.as_ref()
-            .and_then(|tool| tool.get("action"))
-            .cloned()
-            .unwrap_or_else(|| json!("generate")),
+        Value::String(operation.as_str().to_string()),
     );
     for key in ["output_format", "partial_images", "size", "quality"] {
         let tool_value = tool.as_ref().and_then(|tool| tool.get(key));
@@ -1378,6 +1473,14 @@ fn build_openai_image_provider_body_from_openai_responses_body(
     Some((Value::Object(body), Value::Object(summary)))
 }
 
+fn openai_image_operation_from_summary(summary: &Value) -> Option<OpenAiImageOperation> {
+    match summary.get("operation")?.as_str()? {
+        "generate" => Some(OpenAiImageOperation::Generate),
+        "edit" => Some(OpenAiImageOperation::Edit),
+        _ => None,
+    }
+}
+
 fn openai_responses_image_generation_tool(
     object: &serde_json::Map<String, Value>,
 ) -> Option<serde_json::Map<String, Value>> {
@@ -1572,6 +1675,20 @@ fn openai_image_inputs_as_urls(images: &[Value]) -> Vec<Value> {
         .collect()
 }
 
+fn openai_image_inputs_as_api_urls(images: &[Value]) -> Vec<Value> {
+    images
+        .iter()
+        .filter_map(|image| {
+            image
+                .get("image_url")
+                .and_then(Value::as_str)
+                .map(str::trim)
+                .filter(|value| !value.is_empty())
+                .map(|value| json!({ "image_url": value }))
+        })
+        .collect()
+}
+
 fn chatgpt_web_ratio_for_size(size: &str) -> String {
     let Some((width, height)) = size.split_once('x') else {
         return "1:1".to_string();
@@ -1769,7 +1886,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn openai_responses_image_bridge_body_preserves_image_generation_tool() {
+    fn openai_responses_image_bridge_builds_images_api_body() {
         let body_json = json!({
             "model": "gpt-image-2",
             "input": "Draw a glass city",
@@ -1792,14 +1909,74 @@ mod tests {
         )
         .expect("responses image body should convert");
 
-        assert_eq!(provider_body["tools"][0]["type"], "image_generation");
-        assert_eq!(provider_body["tools"][0]["size"], "1024x1024");
-        assert_eq!(provider_body["tools"][0]["output_format"], "png");
         assert_eq!(provider_body["model"], "gpt-image-2");
-        assert_eq!(provider_body["input"], "Draw a glass city");
+        assert_eq!(provider_body["prompt"], "Draw a glass city");
+        assert_eq!(provider_body["size"], "1024x1024");
+        assert_eq!(provider_body["output_format"], "png");
         assert_eq!(provider_body["stream"], true);
+        assert!(provider_body.get("tools").is_none());
+        assert!(provider_body.get("input").is_none());
         assert_eq!(summary["operation"], "generate");
         assert_eq!(summary["output_format"], "png");
+
+        let (sync_provider_body, _) = build_openai_image_provider_body_from_openai_responses_body(
+            &body_json,
+            "gpt-image-2",
+            false,
+        )
+        .expect("responses image body should convert for a sync upstream");
+        assert!(sync_provider_body.get("stream").is_none());
+    }
+
+    #[test]
+    fn responses_image_bridge_uses_the_shared_mapped_model_projection() {
+        let body_json = json!({
+            "model": "image-alias",
+            "input": "Draw a glass city",
+            "tools": [{
+                "type": "image_generation",
+                "quality": "high",
+                "n": 2
+            }],
+            "tool_choice": {"type": "image_generation"}
+        });
+        let (body, _) = build_openai_image_provider_body_from_openai_responses_body(
+            &body_json, "dall-e-3", false,
+        )
+        .expect("Responses image body should convert before provider projection");
+
+        assert!(project_openai_image_api_request_body(
+            &body,
+            "dall-e-3",
+            OpenAiImageOperation::Generate,
+            1,
+        )
+        .is_none());
+        let single = json!({
+            "model": "dall-e-3",
+            "prompt": "Draw a glass city",
+            "quality": "high",
+            "n": 1
+        });
+        let projected = project_openai_image_api_request_body(
+            &single,
+            "dall-e-3",
+            OpenAiImageOperation::Generate,
+            1,
+        )
+        .expect("DALL-E 3 single image request should project");
+        assert_eq!(projected["quality"], "hd");
+
+        let codex_overflow = json!({
+            "model": "gpt-image-2",
+            "prompt": "Draw a glass city",
+            "n": 11
+        });
+        assert!(project_codex_openai_image_api_request_body(
+            &codex_overflow,
+            OpenAiImageOperation::Generate
+        )
+        .is_none());
     }
 
     #[test]

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

@@ -31,8 +31,8 @@ use crate::ai_serving::planner::spec_metadata::local_openai_responses_spec_metad
 use crate::ai_serving::planner::CandidateFailureDiagnostic;
 use crate::ai_serving::{
     ai_local_execution_contract_for_formats, extract_pool_sticky_session_token,
-    resolve_local_decision_execution_runtime_auth_context, ExecutionRuntimeAuthContext,
-    GatewayControlDecision, PlannerAppState,
+    openai_responses_request_operation, resolve_local_decision_execution_runtime_auth_context,
+    ExecutionRuntimeAuthContext, GatewayControlDecision, PlannerAppState,
 };
 use crate::client_session_affinity::client_session_affinity_from_parts;
 use crate::{AppState, GatewayError};
@@ -91,7 +91,9 @@ pub(crate) async fn resolve_local_openai_responses_decision_input(
         state,
         auth_context.clone(),
         Some(requested_model.as_str()),
+        decision.auth_endpoint_signature.as_deref(),
         None,
+        &decision.model_directive_policy,
     )
     .await
     {
@@ -161,6 +163,7 @@ pub(crate) async fn materialize_local_openai_responses_candidate_attempts(
     spec: LocalOpenAiResponsesSpec,
 ) -> Result<(Vec<LocalOpenAiResponsesCandidateAttempt>, usize), GatewayError> {
     let spec_metadata = local_openai_responses_spec_metadata(spec);
+    let request_operation = openai_responses_request_operation(spec_metadata.api_format, body_json);
     let planner_state = PlannerAppState::new(state);
     let sticky_session_token = extract_pool_sticky_session_token(body_json);
     let auth_context: &ExecutionRuntimeAuthContext = &input.auth_context;
@@ -171,8 +174,10 @@ pub(crate) async fn materialize_local_openai_responses_candidate_attempts(
     );
     let preselection = preselect_local_execution_candidates_with_serving(
         planner_state,
+        &input.model_directive_policy,
         spec_metadata.api_format,
         &input.requested_model,
+        request_operation,
         spec_metadata.require_streaming,
         input.required_capabilities.as_ref(),
         &input.auth_snapshot,
@@ -259,6 +264,7 @@ pub(crate) async fn build_local_openai_responses_candidate_attempt_source<'a>(
     spec: LocalOpenAiResponsesSpec,
 ) -> Result<(LocalOpenAiResponsesCandidateAttemptSource<'a>, usize), GatewayError> {
     let spec_metadata = local_openai_responses_spec_metadata(spec);
+    let request_operation = openai_responses_request_operation(spec_metadata.api_format, body_json);
     let planner_state = PlannerAppState::new(state);
     let sticky_session_token = extract_pool_sticky_session_token(body_json);
     let auth_context: &ExecutionRuntimeAuthContext = &input.auth_context;
@@ -280,9 +286,11 @@ pub(crate) async fn build_local_openai_responses_candidate_attempt_source<'a>(
     Ok(
         build_lazy_requested_model_execution_candidate_attempt_source_with_serving(
             planner_state,
+            &input.model_directive_policy,
             trace_id,
             spec_metadata.api_format,
             &input.requested_model,
+            request_operation,
             spec_metadata.require_streaming,
             &input.auth_snapshot,
             input.client_session_affinity.as_ref(),
@@ -365,8 +373,10 @@ pub(crate) async fn build_local_openai_responses_image_candidate_attempt_source<
     );
     let preselection = preselect_local_execution_candidates_for_api_formats_with_serving(
         planner_state,
+        &input.model_directive_policy,
         spec_metadata.api_format,
         &input.requested_model,
+        None,
         false,
         input.required_capabilities.as_ref(),
         &input.auth_snapshot,

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

@@ -146,6 +146,7 @@ pub(crate) fn build_standard_stream_plan_from_decision(
         &provider_request_headers,
         &provider_request_body_value,
     )?;
+    let stream = payload.upstream_is_stream;
     let plan = build_ai_execution_plan_from_decision(
         &mut payload,
         AiExecutionPlanFromDecisionParts {
@@ -155,7 +156,7 @@ pub(crate) fn build_standard_stream_plan_from_decision(
             headers: std::mem::take(&mut provider_request_headers),
             content_type,
             body: RequestBody::from_json(provider_request_body_value),
-            stream: true,
+            stream,
         },
     );
 

apps/aether-gateway/src/ai_serving/planner/state/candidate_runtime.rs

@@ -10,16 +10,15 @@ impl<'a> PlannerAppState<'a> {
         api_key_id: &str,
         requested_model: Option<&str>,
         explicit_required_capabilities: Option<&Value>,
+        model_directive_base_model: Option<&str>,
     ) -> Option<Value> {
-        let enable_model_directives =
-            crate::system_features::reasoning_model_directive_enabled(self.app()).await;
         crate::request_candidate_runtime::resolve_request_candidate_required_capabilities(
             self.app(),
             user_id,
             api_key_id,
             requested_model,
             explicit_required_capabilities,
-            enable_model_directives,
+            model_directive_base_model,
         )
         .await
     }

apps/aether-gateway/src/ai_serving/planner/state/scheduler.rs

@@ -20,14 +20,8 @@ impl<'a> PlannerAppState<'a> {
         auth_snapshot: Option<&GatewayAuthApiKeySnapshot>,
         client_session_affinity: Option<&ClientSessionAffinity>,
         now_unix_secs: u64,
+        enable_model_directives: bool,
     ) -> Result<Vec<SchedulerMinimalCandidateSelectionCandidate>, GatewayError> {
-        let enable_model_directives =
-            crate::system_features::reasoning_model_directive_enabled_for_api_format_and_model(
-                self.app(),
-                api_format,
-                Some(global_model_name),
-            )
-            .await;
         crate::scheduler::candidate::list_selectable_candidates(
             self.app().data.as_ref(),
             self.app(),
@@ -52,6 +46,39 @@ impl<'a> PlannerAppState<'a> {
         auth_snapshot: Option<&GatewayAuthApiKeySnapshot>,
         client_session_affinity: Option<&ClientSessionAffinity>,
         now_unix_secs: u64,
+        enable_model_directives: bool,
+    ) -> Result<
+        (
+            Vec<SchedulerMinimalCandidateSelectionCandidate>,
+            Vec<SchedulerSkippedCandidate>,
+        ),
+        GatewayError,
+    > {
+        self.list_selectable_candidates_with_skip_reasons_for_request_operation(
+            api_format,
+            global_model_name,
+            require_streaming,
+            required_capabilities,
+            auth_snapshot,
+            client_session_affinity,
+            now_unix_secs,
+            enable_model_directives,
+            None,
+        )
+        .await
+    }
+
+    pub(crate) async fn list_selectable_candidates_with_skip_reasons_for_request_operation(
+        self,
+        api_format: &str,
+        global_model_name: &str,
+        require_streaming: bool,
+        required_capabilities: Option<&serde_json::Value>,
+        auth_snapshot: Option<&GatewayAuthApiKeySnapshot>,
+        client_session_affinity: Option<&ClientSessionAffinity>,
+        now_unix_secs: u64,
+        enable_model_directives: bool,
+        request_operation: Option<&str>,
     ) -> Result<
         (
             Vec<SchedulerMinimalCandidateSelectionCandidate>,
@@ -63,16 +90,8 @@ impl<'a> PlannerAppState<'a> {
         let wait_interval = Duration::from_millis(API_KEY_CONCURRENCY_WAIT_POLL_INTERVAL_MS.max(1));
         let wait_deadline = Instant::now() + wait_timeout;
         let mut attempt_now_unix_secs = now_unix_secs;
-        let enable_model_directives =
-            crate::system_features::reasoning_model_directive_enabled_for_api_format_and_model(
-                self.app(),
-                api_format,
-                Some(global_model_name),
-            )
-            .await;
-
         loop {
-            let result = crate::scheduler::candidate::list_selectable_candidates_with_skip_reasons(
+            let result = crate::scheduler::candidate::list_selectable_candidates_with_skip_reasons_for_request_operation(
                 self.app().data.as_ref(),
                 self.app(),
                 api_format,
@@ -83,6 +102,7 @@ impl<'a> PlannerAppState<'a> {
                 client_session_affinity,
                 attempt_now_unix_secs,
                 enable_model_directives,
+                request_operation,
             )
             .await?;
 

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

@@ -3,10 +3,15 @@ pub(crate) use aether_ai_formats::api::{
     aggregate_openai_chat_stream_sync_response, aggregate_openai_responses_stream_sync_response,
     aggregate_standard_chat_stream_sync_response, aggregate_standard_cli_stream_sync_response,
     api_format_alias_matches, api_format_storage_aliases,
-    apply_codex_openai_responses_chat_body_edits, apply_codex_openai_responses_special_body_edits,
-    apply_codex_openai_responses_special_headers, apply_model_directive_mapping_patch,
+    apply_codex_openai_compact_terminal_headers, apply_codex_openai_responses_chat_body_edits,
+    apply_codex_openai_responses_lite_header_for_request_body_with_capabilities,
+    apply_codex_openai_responses_lite_header_with_capabilities,
+    apply_codex_openai_responses_special_body_edits,
+    apply_codex_openai_responses_special_body_edits_with_source_model_and_capabilities,
+    apply_codex_openai_special_headers, apply_model_directive_mapping_patch,
     apply_model_directive_overrides_from_model, apply_model_directive_overrides_from_request,
     apply_openai_responses_compact_special_body_edits, build_chatgpt_web_image_request_body,
+    build_codex_model_catalog_metadata, build_codex_openai_image_api_provider_request_body,
     build_core_error_body_for_client_format, build_cross_format_openai_chat_request_body,
     build_cross_format_openai_chat_request_body_with_model_directives,
     build_cross_format_openai_responses_request_body,
@@ -41,17 +46,21 @@ pub(crate) use aether_ai_formats::api::{
     convert_standard_chat_response, convert_standard_cli_response, copy_request_number_field,
     copy_request_number_field_as, core_error_background_report_kind,
     core_error_default_client_api_format, core_success_background_report_kind,
+    default_model_directive_mapping_patch, default_model_directive_suffixes,
     default_model_for_openai_image_operation, encode_done_sse, encode_json_sse,
     encode_kiro_sse_events, endpoint_config_forces_upstream_stream_policy,
     enforce_request_body_stream_field, estimate_kiro_tokens, extract_openai_text_content,
+    finalize_openai_provider_request,
+    finalize_openai_provider_request_with_codex_model_capabilities,
     find_kiro_real_thinking_end_tag, find_kiro_real_thinking_end_tag_at_buffer_end,
-    find_kiro_real_thinking_start_tag, force_upstream_streaming_for_provider,
-    gemini_request_is_image_generation, implicit_sync_finalize_report_kind,
-    is_core_error_finalize_kind, is_matching_stream_http_request, is_matching_stream_request,
-    is_openai_image_stream_request, is_openai_responses_family_format, is_openai_responses_format,
-    kiro_crc32, map_claude_stop_reason, map_openai_reasoning_effort_to_claude_output,
-    map_openai_reasoning_effort_to_gemini_budget, maybe_bridge_standard_sync_json_to_stream,
-    maybe_build_ai_surface_stream_rewriter,
+    find_kiro_real_thinking_start_tag, forbid_upstream_streaming_for_provider,
+    force_upstream_streaming_for_provider, gemini_request_is_image_generation,
+    implicit_sync_finalize_report_kind, is_core_error_finalize_kind,
+    is_matching_stream_http_request, is_matching_stream_request, is_openai_image_stream_request,
+    is_openai_responses_compact_format, is_openai_responses_family_format,
+    is_openai_responses_format, kiro_crc32, map_claude_stop_reason,
+    map_openai_reasoning_effort_to_claude_output, map_openai_reasoning_effort_to_gemini_budget,
+    maybe_bridge_standard_sync_json_to_stream, maybe_build_ai_surface_stream_rewriter,
     maybe_build_openai_chat_cross_format_sync_product_from_normalized_payload,
     maybe_build_openai_image_sync_finalize_product,
     maybe_build_openai_responses_cross_format_sync_product_from_normalized_payload,
@@ -60,51 +69,60 @@ pub(crate) use aether_ai_formats::api::{
     maybe_build_standard_cross_format_sync_product_from_normalized_payload,
     maybe_build_standard_same_format_sync_body_from_normalized_payload,
     maybe_build_standard_sync_finalize_product_from_normalized_payload, model_directive_base_model,
-    normalize_api_format_alias, normalize_claude_request_to_openai_chat_request,
-    normalize_gemini_request_to_openai_chat_request, normalize_openai_image_request,
-    normalize_openai_image_request_with_options,
+    model_directive_builtin_suffix_supported_for_source_model,
+    model_directive_suffix_has_builtin_mapping, normalize_api_format_alias,
+    normalize_claude_request_to_openai_chat_request,
+    normalize_gemini_request_to_openai_chat_request, normalize_openai_image_quality,
+    normalize_openai_image_request, normalize_openai_image_request_with_options,
     normalize_openai_responses_request_to_openai_chat_request,
     normalize_provider_private_report_context, normalize_provider_private_response_value,
     normalize_standard_request_to_openai_chat_request, openai_image_operation_from_path,
-    parse_direct_request_body, parse_openai_stop_sequences, parse_openai_tool_result_content,
-    prepare_local_success_response_parts, prepare_local_success_response_parts_owned,
-    provider_adaptation_allows_sync_finalize_envelope, provider_adaptation_anchor_api_format,
-    provider_adaptation_descriptor_for_envelope, provider_adaptation_descriptor_for_provider_type,
+    parse_codex_auth_identity, parse_direct_request_body, parse_model_directive,
+    parse_model_directive_with_suffixes, parse_openai_stop_sequences,
+    parse_openai_tool_result_content, prepare_local_success_response_parts,
+    prepare_local_success_response_parts_owned, project_codex_openai_image_api_request_body,
+    project_openai_image_api_request_body, provider_adaptation_allows_sync_finalize_envelope,
+    provider_adaptation_anchor_api_format, provider_adaptation_descriptor_for_envelope,
+    provider_adaptation_descriptor_for_provider_type,
     provider_adaptation_requires_eventstream_accept,
     provider_adaptation_should_unwrap_stream_envelope,
     provider_private_response_allows_sync_finalize, request_candidate_api_format_preference,
     request_candidate_api_formats, request_conversion_kind,
     request_conversion_requires_enable_flag, request_path_implies_stream_request,
     resolve_claude_stream_spec, resolve_claude_sync_spec,
-    resolve_execution_runtime_stream_plan_kind, resolve_execution_runtime_sync_plan_kind,
-    resolve_finalize_stream_rewrite_mode, resolve_gemini_files_stream_spec,
-    resolve_gemini_files_sync_spec, resolve_gemini_stream_spec, resolve_gemini_sync_spec,
-    resolve_local_image_stream_spec, resolve_local_image_sync_spec,
+    resolve_codex_responses_model_capabilities, resolve_execution_runtime_stream_plan_kind,
+    resolve_execution_runtime_sync_plan_kind, resolve_finalize_stream_rewrite_mode,
+    resolve_gemini_files_stream_spec, resolve_gemini_files_sync_spec, resolve_gemini_stream_spec,
+    resolve_gemini_sync_spec, resolve_local_image_stream_spec, resolve_local_image_sync_spec,
     resolve_local_same_format_stream_spec, resolve_local_same_format_sync_spec,
     resolve_local_video_sync_spec, resolve_openai_chat_max_tokens,
     resolve_openai_embedding_sync_spec, resolve_openai_responses_stream_spec,
     resolve_openai_responses_sync_spec, resolve_requested_gemini_image_model_for_request,
     resolve_requested_openai_image_model_for_request,
+    resolve_upstream_is_stream_for_provider as resolve_format_upstream_is_stream_for_provider,
     resolve_upstream_is_stream_from_endpoint_config, sanitize_request_path,
     sanitize_request_path_and_query, sanitize_request_query_string,
     stream_body_contains_error_event, supports_stream_execution_decision_kind,
     supports_sync_execution_decision_kind, sync_chat_response_conversion_kind,
-    sync_cli_response_conversion_kind, transform_provider_private_stream_line, value_as_u64,
-    AiControlPlanRequest, AiSurfaceFinalizeError, AiSurfaceStreamRewriter, CanonicalStreamFrame,
+    sync_cli_response_conversion_kind, transform_provider_private_stream_line,
+    validate_openai_provider_request_contract, value_as_u64, AiControlPlanRequest,
+    AiSurfaceFinalizeError, AiSurfaceStreamRewriter, CanonicalStreamFrame,
     ChatGptWebImageRequestError, ClaudeClientEmitter, ClaudeProviderState,
-    ExecutionRuntimeAuthContext, FinalizeStreamRewriteMode, FormatContext, GeminiClientEmitter,
-    GeminiImageRequestForOpenAi, GeminiProviderState, KiroToClaudeCliStreamState,
-    LocalCoreSyncErrorKind, LocalGeminiFilesSpec, LocalOpenAiImageSpec, LocalOpenAiResponsesSpec,
-    LocalSameFormatProviderFamily, LocalSameFormatProviderSpec, LocalStandardSourceFamily,
-    LocalStandardSourceMode, LocalStandardSpec, LocalSyncReportParts, LocalVideoCreateFamily,
-    LocalVideoCreateSpec, NormalizedOpenAiImageRequest, OpenAIChatClientEmitter,
-    OpenAIChatProviderState, OpenAIResponsesClientEmitter, OpenAIResponsesProviderState,
-    OpenAiImageNormalizeOptions, OpenAiImageOperation, OpenAiImageRequestForGemini,
-    OpenAiImageResponseFormat, OpenAiImageStreamState, OpenAiImageSyncFinalizeProduct,
+    CodexResponsesModelCapabilities, ExecutionRuntimeAuthContext, FinalizeStreamRewriteMode,
+    FormatContext, GeminiClientEmitter, GeminiImageRequestForOpenAi, GeminiProviderState,
+    KiroToClaudeCliStreamState, LocalCoreSyncErrorKind, LocalGeminiFilesSpec, LocalOpenAiImageSpec,
+    LocalOpenAiResponsesSpec, LocalSameFormatProviderFamily, LocalSameFormatProviderSpec,
+    LocalStandardSourceFamily, LocalStandardSourceMode, LocalStandardSpec, LocalSyncReportParts,
+    LocalVideoCreateFamily, LocalVideoCreateSpec, NormalizedOpenAiImageRequest,
+    OpenAIChatClientEmitter, OpenAIChatProviderState, OpenAIResponsesClientEmitter,
+    OpenAIResponsesProviderState, OpenAiImageNormalizeOptions, OpenAiImageOperation,
+    OpenAiImageRequestForGemini, OpenAiImageResponseFormat, OpenAiImageStreamState,
+    OpenAiImageSyncFinalizeProduct, OpenAiProviderRequestFinalization,
     ProviderAdaptationDescriptor, ProviderAdaptationSurface, ProviderPrivateStreamNormalizer,
-    RequestConversionKind, StandardCrossFormatSyncProduct, StandardSyncFinalizeNormalizedProduct,
-    StreamingStandardFormatMatrix, SyncChatResponseConversionKind, SyncCliResponseConversionKind,
-    SyncToStreamBridgeOutcome, ANTIGRAVITY_V1INTERNAL_ENVELOPE_NAME, CLAUDE_CHAT_STREAM_PLAN_KIND,
+    ReasoningEffort, RequestConversionKind, ServiceTier, StandardCrossFormatSyncProduct,
+    StandardSyncFinalizeNormalizedProduct, StreamingStandardFormatMatrix,
+    SyncChatResponseConversionKind, SyncCliResponseConversionKind, SyncToStreamBridgeOutcome,
+    ANTIGRAVITY_V1INTERNAL_ENVELOPE_NAME, CLAUDE_CHAT_STREAM_PLAN_KIND,
     CLAUDE_CHAT_STREAM_SUCCESS_REPORT_KIND, CLAUDE_CHAT_SYNC_ERROR_REPORT_KIND,
     CLAUDE_CHAT_SYNC_FINALIZE_REPORT_KIND, CLAUDE_CHAT_SYNC_PLAN_KIND,
     CLAUDE_CHAT_SYNC_SUCCESS_REPORT_KIND, CLAUDE_CLI_STREAM_PLAN_KIND,
@@ -125,22 +143,28 @@ pub(crate) use aether_ai_formats::api::{
     GEMINI_FILES_DELETE_PLAN_KIND, GEMINI_FILES_DOWNLOAD_PLAN_KIND, GEMINI_FILES_GET_PLAN_KIND,
     GEMINI_FILES_LIST_PLAN_KIND, GEMINI_FILES_UPLOAD_PLAN_KIND, GEMINI_VIDEO_CANCEL_SYNC_PLAN_KIND,
     GEMINI_VIDEO_CREATE_SYNC_FINALIZE_REPORT_KIND, GEMINI_VIDEO_CREATE_SYNC_PLAN_KIND,
-    KIRO_ENVELOPE_NAME, KIRO_MAX_THINKING_BUFFER, OPENAI_CHAT_STREAM_PLAN_KIND,
-    OPENAI_CHAT_STREAM_SUCCESS_REPORT_KIND, OPENAI_CHAT_SYNC_ERROR_REPORT_KIND,
-    OPENAI_CHAT_SYNC_FINALIZE_REPORT_KIND, OPENAI_CHAT_SYNC_PLAN_KIND,
-    OPENAI_CHAT_SYNC_SUCCESS_REPORT_KIND, OPENAI_EMBEDDING_SYNC_PLAN_KIND,
-    OPENAI_IMAGE_STREAM_PLAN_KIND, OPENAI_IMAGE_STREAM_SUCCESS_REPORT_KIND,
-    OPENAI_IMAGE_SYNC_FINALIZE_REPORT_KIND, OPENAI_IMAGE_SYNC_PLAN_KIND,
-    OPENAI_IMAGE_SYNC_SUCCESS_REPORT_KIND, OPENAI_RERANK_SYNC_PLAN_KIND,
-    OPENAI_RESPONSES_COMPACT_STREAM_PLAN_KIND, OPENAI_RESPONSES_COMPACT_STREAM_SUCCESS_REPORT_KIND,
+    KIRO_ENVELOPE_NAME, KIRO_MAX_THINKING_BUFFER, MODEL_DIRECTIVE_API_FORMATS,
+    OPENAI_CHAT_STREAM_PLAN_KIND, OPENAI_CHAT_STREAM_SUCCESS_REPORT_KIND,
+    OPENAI_CHAT_SYNC_ERROR_REPORT_KIND, OPENAI_CHAT_SYNC_FINALIZE_REPORT_KIND,
+    OPENAI_CHAT_SYNC_PLAN_KIND, OPENAI_CHAT_SYNC_SUCCESS_REPORT_KIND,
+    OPENAI_EMBEDDING_SYNC_PLAN_KIND, OPENAI_IMAGE_STREAM_PLAN_KIND,
+    OPENAI_IMAGE_STREAM_SUCCESS_REPORT_KIND, OPENAI_IMAGE_SYNC_FINALIZE_REPORT_KIND,
+    OPENAI_IMAGE_SYNC_PLAN_KIND, OPENAI_IMAGE_SYNC_SUCCESS_REPORT_KIND,
+    OPENAI_RERANK_SYNC_PLAN_KIND, OPENAI_RESPONSES_COMPACT_STREAM_PLAN_KIND,
+    OPENAI_RESPONSES_COMPACT_STREAM_SUCCESS_REPORT_KIND,
     OPENAI_RESPONSES_COMPACT_SYNC_ERROR_REPORT_KIND,
     OPENAI_RESPONSES_COMPACT_SYNC_FINALIZE_REPORT_KIND, OPENAI_RESPONSES_COMPACT_SYNC_PLAN_KIND,
     OPENAI_RESPONSES_COMPACT_SYNC_SUCCESS_REPORT_KIND, OPENAI_RESPONSES_STREAM_PLAN_KIND,
     OPENAI_RESPONSES_STREAM_SUCCESS_REPORT_KIND, OPENAI_RESPONSES_SYNC_ERROR_REPORT_KIND,
     OPENAI_RESPONSES_SYNC_FINALIZE_REPORT_KIND, OPENAI_RESPONSES_SYNC_PLAN_KIND,
-    OPENAI_RESPONSES_SYNC_SUCCESS_REPORT_KIND, OPENAI_VIDEO_CANCEL_SYNC_PLAN_KIND,
+    OPENAI_RESPONSES_SYNC_SUCCESS_REPORT_KIND, OPENAI_SEARCH_SYNC_PLAN_KIND,
+    OPENAI_SEARCH_SYNC_SUCCESS_REPORT_KIND, OPENAI_VIDEO_CANCEL_SYNC_PLAN_KIND,
     OPENAI_VIDEO_CONTENT_PLAN_KIND, OPENAI_VIDEO_CREATE_SYNC_FINALIZE_REPORT_KIND,
     OPENAI_VIDEO_CREATE_SYNC_PLAN_KIND, OPENAI_VIDEO_DELETE_SYNC_PLAN_KIND,
     OPENAI_VIDEO_REMIX_SYNC_PLAN_KIND,
 };
-pub(crate) use aether_ai_formats::{is_embedding_api_format, is_rerank_api_format};
+pub(crate) use aether_ai_formats::{
+    api_format_defaults_to_client_error_failover, api_format_defaults_to_non_stream,
+    api_format_permission_covers, intersect_api_format_allowed_lists, is_embedding_api_format,
+    is_rerank_api_format, openai_responses_request_operation,
+};

apps/aether-gateway/src/api/ai/openai.rs

@@ -5,6 +5,7 @@ pub(crate) fn normalized_signature(api_format: &str) -> Option<&'static str> {
         "openai:rerank" => Some("openai:rerank"),
         "openai:responses" => Some("openai:responses"),
         "openai:responses:compact" => Some("openai:responses:compact"),
+        "openai:search" => Some("openai:search"),
         "openai:image" => Some("openai:image"),
         "openai:video" => Some("openai:video"),
         _ => None,
@@ -18,6 +19,7 @@ pub(crate) fn local_path(api_format: &str) -> Option<&'static str> {
         "openai:rerank" => Some("/v1/rerank"),
         "openai:responses" => Some("/v1/responses"),
         "openai:responses:compact" => Some("/v1/responses/compact"),
+        "openai:search" => Some("/v1/alpha/search"),
         "openai:image" => Some("/v1/images/generations"),
         "openai:video" => Some("/v1/videos"),
         _ => None,

apps/aether-gateway/src/api/ai/registry.rs

@@ -15,6 +15,7 @@ const AI_POST_ROUTE_PATTERNS: &[&str] = &[
     "/v1/messages/count_tokens",
     "/v1/responses",
     "/v1/responses/compact",
+    "/v1/alpha/search",
     "/v1/images/generations",
     "/v1/images/edits",
     "/v1/interactions",
@@ -120,6 +121,7 @@ mod tests {
                 "/api/v1/services/embeddings/multimodal-embedding/multimodal-embedding",
             ),
             ("openai:rerank", "openai", "rerank", "/v1/rerank"),
+            ("openai:search", "openai", "search", "/v1/alpha/search"),
             ("jina:rerank", "jina", "rerank", "/v1/rerank"),
         ] {
             assert_eq!(

apps/aether-gateway/src/async_task/runtime.rs

@@ -144,34 +144,38 @@ pub(crate) fn spawn_video_task_poller(state: AppState) -> Option<JoinHandle<()>>
         return None;
     }
 
-    Some(tokio::spawn(async move {
-        let mut interval = tokio::time::interval(config.interval);
-        interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
-        interval.tick().await;
-        let mut deferred_since = None;
-        loop {
+    Some(crate::task_runtime::spawn_singleton_worker(
+        state,
+        crate::task_runtime::TASK_KEY_VIDEO_TASK_POLLER,
+        move |state| async move {
+            let mut interval = tokio::time::interval(config.interval);
+            interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
             interval.tick().await;
-            if state
-                .data
-                .should_defer_maintenance_for_database_pool_pressure(&mut deferred_since)
-            {
-                debug!(
-                    event_name = "video_task_poller_deferred",
-                    log_type = "event",
-                    "gateway video task poller deferred because database pool has no idle reserve"
-                );
-                continue;
+            let mut deferred_since = None;
+            loop {
+                interval.tick().await;
+                if state
+                    .data
+                    .should_defer_maintenance_for_database_pool_pressure(&mut deferred_since)
+                {
+                    debug!(
+                        event_name = "video_task_poller_deferred",
+                        log_type = "event",
+                        "gateway video task poller deferred because database pool has no idle reserve"
+                    );
+                    continue;
+                }
+                if let Err(err) = poll_video_tasks_once(&state, config.batch_size).await {
+                    warn!(
+                        event_name = "video_task_poller_tick_failed",
+                        log_type = "event",
+                        error = ?err,
+                        "gateway video task poller tick failed"
+                    );
+                }
             }
-            if let Err(err) = poll_video_tasks_once(&state, config.batch_size).await {
-                warn!(
-                    event_name = "video_task_poller_tick_failed",
-                    log_type = "event",
-                    error = ?err,
-                    "gateway video task poller tick failed"
-                );
-            }
-        }
-    }))
+        },
+    ))
 }
 
 async fn fetch_video_task_refresh_attempt(

apps/aether-gateway/src/backup/config.rs

@@ -11,6 +11,7 @@ pub(crate) struct S3BackupConfig {
     pub(crate) scope: BackupScope,
     pub(crate) endpoint: String,
     pub(crate) region: String,
+    pub(crate) user_agent: String,
     pub(crate) bucket: String,
     pub(crate) prefix: String,
     pub(crate) access_key_id: String,
@@ -104,6 +105,8 @@ impl S3BackupConfig {
             endpoint,
             region: optional_string(entries, "backup_s3_region")?
                 .unwrap_or_else(|| "auto".to_string()),
+            user_agent: optional_string(entries, "backup_s3_user_agent")?
+                .unwrap_or_else(|| "rclone/v1.68.0".to_string()),
             bucket,
             prefix: optional_string(entries, "backup_s3_prefix")?
                 .unwrap_or_else(|| "aether/backups/".to_string()),
@@ -179,6 +182,7 @@ fn config_label(key: &str) -> &str {
     match key {
         "backup_s3_endpoint" => "Endpoint（S3 地址）",
         "backup_s3_region" => "Region（S3 区域）",
+        "backup_s3_user_agent" => "User-Agent（请求头标识）",
         "backup_s3_bucket" => "Bucket（存储桶）",
         "backup_s3_prefix" => "Prefix（备份前缀）",
         "backup_s3_access_key_id" => "Access Key ID（访问密钥 ID）",
@@ -384,6 +388,7 @@ mod tests {
 
         assert_eq!(config.scope, BackupScope::Data);
         assert_eq!(config.region, "auto");
+        assert_eq!(config.user_agent, "rclone/v1.68.0");
         assert_eq!(config.prefix, "aether/backups/");
         assert_eq!(config.path_style, true);
         assert_eq!(config.compression, "zstd");

apps/aether-gateway/src/backup/executor.rs

@@ -132,6 +132,7 @@ mod tests {
             scope,
             endpoint: "https://example.com".to_string(),
             region: "auto".to_string(),
+            user_agent: "rclone/v1.68.0".to_string(),
             bucket: "aether-backups".to_string(),
             prefix: "prod/".to_string(),
             access_key_id: "test-access-key".to_string(),

apps/aether-gateway/src/backup/store.rs

@@ -6,7 +6,8 @@ use bytes::Bytes;
 use futures_util::TryStreamExt;
 use object_store::aws::AmazonS3Builder;
 use object_store::path::Path;
-use object_store::ObjectStore;
+use object_store::{ClientOptions, ObjectStore};
+use reqwest::header::HeaderValue;
 use tokio::sync::RwLock;
 
 use super::config::S3BackupConfig;
@@ -84,7 +85,19 @@ pub(crate) struct ObjectStoreS3BackupStore {
 
 impl ObjectStoreS3BackupStore {
     pub(crate) fn from_config(config: &S3BackupConfig) -> Result<Self, BackupStoreError> {
+        // 部分 S3 兼容网关（如中国科技云 s3.cstcloud.cn）按 User-Agent 放行请求，
+        // object_store 默认 UA 会被拒，因此允许自定义 User-Agent。
+        let client_options = if config.user_agent.trim().is_empty() {
+            ClientOptions::new()
+        } else {
+            ClientOptions::new().with_user_agent(
+                HeaderValue::from_str(config.user_agent.trim()).map_err(|error| {
+                    BackupStoreError::new(format!("S3 备份 User-Agent 配置无效: {error}"))
+                })?,
+            )
+        };
         let store = AmazonS3Builder::new()
+            .with_client_options(client_options)
             .with_endpoint(config.endpoint.clone())
             .with_region(config.region.clone())
             .with_bucket_name(config.bucket.clone())

apps/aether-gateway/src/backup/task.rs

@@ -31,6 +31,7 @@ const S3_BACKUP_CONFIG_KEYS: &[&str] = &[
     "backup_s3_scope",
     "backup_s3_endpoint",
     "backup_s3_region",
+    "backup_s3_user_agent",
     "backup_s3_bucket",
     "backup_s3_prefix",
     "backup_s3_access_key_id",

apps/aether-gateway/src/backup/worker.rs

@@ -20,17 +20,21 @@ pub(crate) fn spawn_s3_backup_worker(app: AppState) -> Option<JoinHandle<()>> {
         return None;
     }
 
-    Some(tokio::spawn(async move {
-        let mut interval = tokio::time::interval(S3_BACKUP_WORKER_INTERVAL);
-        interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
-        interval.tick().await;
-        loop {
+    Some(crate::task_runtime::spawn_singleton_worker(
+        app,
+        S3_BACKUP_WORKER_TASK_KEY,
+        |app| async move {
+            let mut interval = tokio::time::interval(S3_BACKUP_WORKER_INTERVAL);
+            interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
             interval.tick().await;
-            if let Err(error) = run_s3_backup_schedule_tick(&app, Utc::now()).await {
-                warn!(error = ?error, "S3 backup schedule tick failed");
+            loop {
+                interval.tick().await;
+                if let Err(error) = run_s3_backup_schedule_tick(&app, Utc::now()).await {
+                    warn!(error = ?error, "S3 backup schedule tick failed");
+                }
             }
-        }
-    }))
+        },
+    ))
 }
 
 async fn run_s3_backup_schedule_tick(

apps/aether-gateway/src/cache/candidate_page.rs

@@ -82,6 +82,7 @@ pub(crate) struct CandidateRowPageCacheKey {
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct CandidatePageCacheKey {
     requested_model: String,
+    request_operation: String,
     client_api_format: String,
     auth_identity: CandidatePageAuthIdentity,
     require_streaming: bool,
@@ -92,6 +93,7 @@ pub(crate) struct CandidatePageCacheKey {
     preselection_mode: &'static str,
     use_api_format_alias_match: bool,
     client_session_affinity_hash: String,
+    model_directive_policy_hash: String,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -130,6 +132,7 @@ impl CandidatePageCacheKey {
     #[allow(clippy::too_many_arguments)]
     pub(crate) fn new(
         requested_model: &str,
+        request_operation: Option<&str>,
         client_api_format: &str,
         require_streaming: bool,
         auth_snapshot: &GatewayAuthApiKeySnapshot,
@@ -140,9 +143,11 @@ impl CandidatePageCacheKey {
         preselection_mode: &'static str,
         use_api_format_alias_match: bool,
         client_session_affinity: Option<&ClientSessionAffinity>,
+        model_directive_policy_hash: &str,
     ) -> Self {
         Self {
             requested_model: normalize_text_key(requested_model),
+            request_operation: normalize_text_key(request_operation.unwrap_or_default()),
             client_api_format: normalize_api_format(client_api_format),
             auth_identity: CandidatePageAuthIdentity::from_auth_snapshot(auth_snapshot),
             require_streaming,
@@ -153,6 +158,7 @@ impl CandidatePageCacheKey {
             preselection_mode,
             use_api_format_alias_match,
             client_session_affinity_hash: client_session_affinity_key(client_session_affinity),
+            model_directive_policy_hash: normalize_text_key(model_directive_policy_hash),
         }
     }
 }
@@ -161,6 +167,7 @@ impl CandidateResolvedPageCacheKey {
     #[allow(clippy::too_many_arguments)]
     pub(crate) fn new(
         requested_model: &str,
+        request_operation: Option<&str>,
         client_api_format: &str,
         require_streaming: bool,
         auth_snapshot: &GatewayAuthApiKeySnapshot,
@@ -171,11 +178,13 @@ impl CandidateResolvedPageCacheKey {
         preselection_mode: &'static str,
         use_api_format_alias_match: bool,
         client_session_affinity: Option<&ClientSessionAffinity>,
+        model_directive_policy_hash: &str,
         resolution_mode: AiCandidateResolutionMode,
     ) -> Self {
         Self {
             page_key: CandidatePageCacheKey::new(
                 requested_model,
+                request_operation,
                 client_api_format,
                 require_streaming,
                 auth_snapshot,
@@ -186,6 +195,7 @@ impl CandidateResolvedPageCacheKey {
                 preselection_mode,
                 use_api_format_alias_match,
                 client_session_affinity,
+                model_directive_policy_hash,
             ),
             resolution_mode: resolution_mode_name(resolution_mode),
         }
@@ -559,6 +569,7 @@ mod tests {
         let auth_b = auth_snapshot("user-b", "key-a");
         let base = CandidatePageCacheKey::new(
             "gpt-4o",
+            None,
             "openai:chat",
             true,
             &auth_a,
@@ -569,9 +580,11 @@ mod tests {
             "provider_endpoint_key_model",
             true,
             None,
+            "policy-a",
         );
         let different_user = CandidatePageCacheKey::new(
             "gpt-4o",
+            None,
             "openai:chat",
             true,
             &auth_b,
@@ -582,9 +595,11 @@ mod tests {
             "provider_endpoint_key_model",
             true,
             None,
+            "policy-a",
         );
         let different_model = CandidatePageCacheKey::new(
             "gpt-4.1",
+            None,
             "openai:chat",
             true,
             &auth_a,
@@ -595,9 +610,26 @@ mod tests {
             "provider_endpoint_key_model",
             true,
             None,
+            "policy-a",
+        );
+        let different_operation = CandidatePageCacheKey::new(
+            "gpt-4o",
+            Some("compact"),
+            "openai:chat",
+            true,
+            &auth_a,
+            Some(&json!({"vision": true})),
+            None,
+            Some("bearer"),
+            7,
+            "provider_endpoint_key_model",
+            true,
+            None,
+            "policy-a",
         );
         let different_format = CandidatePageCacheKey::new(
             "gpt-4o",
+            None,
             "openai:responses",
             true,
             &auth_a,
@@ -608,9 +640,11 @@ mod tests {
             "provider_endpoint_key_model",
             true,
             None,
+            "policy-a",
         );
         let different_capabilities = CandidatePageCacheKey::new(
             "gpt-4o",
+            None,
             "openai:chat",
             true,
             &auth_a,
@@ -621,11 +655,96 @@ mod tests {
             "provider_endpoint_key_model",
             true,
             None,
+            "policy-a",
+        );
+        let same_policy = CandidatePageCacheKey::new(
+            "gpt-4o",
+            None,
+            "openai:chat",
+            true,
+            &auth_a,
+            Some(&json!({"vision": true})),
+            None,
+            Some("bearer"),
+            7,
+            "provider_endpoint_key_model",
+            true,
+            None,
+            "policy-a",
+        );
+        let different_policy = CandidatePageCacheKey::new(
+            "gpt-4o",
+            None,
+            "openai:chat",
+            true,
+            &auth_a,
+            Some(&json!({"vision": true})),
+            None,
+            Some("bearer"),
+            7,
+            "provider_endpoint_key_model",
+            true,
+            None,
+            "policy-b",
         );
 
+        assert_eq!(base, same_policy);
         assert_ne!(base, different_user);
         assert_ne!(base, different_model);
+        assert_ne!(base, different_operation);
         assert_ne!(base, different_format);
         assert_ne!(base, different_capabilities);
+        assert_ne!(base, different_policy);
+
+        let resolved_base = CandidateResolvedPageCacheKey::new(
+            "gpt-4o",
+            None,
+            "openai:chat",
+            true,
+            &auth_a,
+            Some(&json!({"vision": true})),
+            None,
+            Some("bearer"),
+            7,
+            "provider_endpoint_key_model",
+            true,
+            None,
+            "policy-a",
+            AiCandidateResolutionMode::Standard,
+        );
+        let resolved_same_policy = CandidateResolvedPageCacheKey::new(
+            "gpt-4o",
+            None,
+            "openai:chat",
+            true,
+            &auth_a,
+            Some(&json!({"vision": true})),
+            None,
+            Some("bearer"),
+            7,
+            "provider_endpoint_key_model",
+            true,
+            None,
+            "policy-a",
+            AiCandidateResolutionMode::Standard,
+        );
+        let resolved_different_policy = CandidateResolvedPageCacheKey::new(
+            "gpt-4o",
+            None,
+            "openai:chat",
+            true,
+            &auth_a,
+            Some(&json!({"vision": true})),
+            None,
+            Some("bearer"),
+            7,
+            "provider_endpoint_key_model",
+            true,
+            None,
+            "policy-b",
+            AiCandidateResolutionMode::Standard,
+        );
+        assert_eq!(resolved_base, resolved_same_policy);
+        assert_ne!(resolved_base, resolved_different_policy);
     }
 }

apps/aether-gateway/src/client_session_affinity.rs

@@ -101,6 +101,29 @@ pub(crate) fn client_session_affinity_from_request(
     client_session_scope_from_request(headers, body_json)?.scheduler_affinity()
 }
 
+pub(crate) fn client_session_affinity_from_api_request(
+    api_format: &str,
+    headers: &http::HeaderMap,
+    body_json: Option<&Value>,
+) -> Option<ClientSessionAffinity> {
+    client_session_scope_from_api_request(api_format, headers, body_json)?.scheduler_affinity()
+}
+
+fn client_session_scope_from_api_request(
+    api_format: &str,
+    headers: &http::HeaderMap,
+    body_json: Option<&Value>,
+) -> Option<ClientSessionScope> {
+    if api_format.trim().eq_ignore_ascii_case("openai:search") {
+        let request = ClientSessionRequest { headers, body_json };
+        return explicit_aether_session_scope(&request, CodexSessionScopeAdapter.family())
+            .or_else(|| codex_search_session_scope(&request))
+            .or_else(|| client_session_scope_from_request(headers, body_json));
+    }
+
+    client_session_scope_from_request(headers, body_json)
+}
+
 pub(crate) fn client_session_scope_from_request(
     headers: &http::HeaderMap,
     body_json: Option<&Value>,
@@ -113,6 +136,22 @@ pub(crate) fn client_session_scope_from_request(
         .or_else(|| extract_scope_from_other_specific_adapters(&request, client_family.as_str()))
 }
 
+fn codex_search_session_scope(request: &ClientSessionRequest<'_>) -> Option<ClientSessionScope> {
+    let session_id = request
+        .body_json?
+        .get("id")?
+        .as_str()
+        .map(str::trim)
+        .filter(|value| !value.is_empty())?;
+    Some(ClientSessionScope::new(
+        CodexSessionScopeAdapter.family(),
+        session_id,
+        None,
+        header_value_str(request.headers, "chatgpt-account-id"),
+        ClientSessionSignalSource::Body,
+    ))
+}
+
 pub(crate) fn client_session_affinity_from_parts(
     parts: &http::request::Parts,
     body_json: Option<&Value>,
@@ -307,7 +346,9 @@ impl ClientSessionScopeAdapter for GenericSessionScopeAdapter {
     }
 
     fn extract_scope(&self, request: &ClientSessionRequest<'_>) -> Option<ClientSessionScope> {
-        if let Some(root_session) = header_value_str(request.headers, "session_id")
+        if let Some(root_session) = header_value_str(request.headers, "session-id")
+            .or_else(|| header_value_str(request.headers, "thread-id"))
+            .or_else(|| header_value_str(request.headers, "session_id"))
             .or_else(|| header_value_str(request.headers, "conversation_id"))
         {
             return Some(ClientSessionScope::new(
@@ -367,7 +408,9 @@ impl ClientSessionScopeAdapter for CodexSessionScopeAdapter {
     }
 
     fn extract_scope(&self, request: &ClientSessionRequest<'_>) -> Option<ClientSessionScope> {
-        header_value_str(request.headers, "session_id")
+        header_value_str(request.headers, "session-id")
+            .or_else(|| header_value_str(request.headers, "thread-id"))
+            .or_else(|| header_value_str(request.headers, "session_id"))
             .or_else(|| header_value_str(request.headers, "conversation_id"))
             .map(|root_session| {
                 ClientSessionScope::new(
@@ -785,6 +828,7 @@ fn has_header_with_prefix(headers: &http::HeaderMap, prefix: &str) -> bool {
 #[cfg(test)]
 mod tests {
     use super::{
+        client_session_affinity_from_api_request,
         client_session_affinity_from_report_context_value, client_session_affinity_from_request,
         client_session_affinity_report_context_value, client_session_scope_from_request,
         ClientSessionSignalSource, AETHER_AGENT_ID_HEADER, AETHER_SESSION_ID_HEADER,
@@ -841,9 +885,10 @@ mod tests {
         let mut headers = HeaderMap::new();
         headers.insert(
             http::header::USER_AGENT,
-            HeaderValue::from_static("codex-tui/0.122.0"),
+            HeaderValue::from_static("codex_cli_rs/0.144.1"),
         );
-        headers.insert("session_id", HeaderValue::from_static("codex-session"));
+        headers.insert("session-id", HeaderValue::from_static("codex-session"));
+        headers.insert("thread-id", HeaderValue::from_static("codex-thread"));
 
         let affinity =
             client_session_affinity_from_request(&headers, None).expect("affinity should build");
@@ -860,7 +905,7 @@ mod tests {
         let mut headers = HeaderMap::new();
         headers.insert(
             http::header::USER_AGENT,
-            HeaderValue::from_static("codex-tui/0.122.0"),
+            HeaderValue::from_static("codex_cli_rs/0.144.1"),
         );
         headers.insert(
             "x-client-request-id",
@@ -1120,4 +1165,28 @@ mod tests {
 
         assert!(client_session_affinity_from_request(&headers, Some(&body)).is_none());
     }
+
+    #[test]
+    fn codex_search_uses_request_id_as_session_affinity() {
+        let mut headers = HeaderMap::new();
+        headers.insert("chatgpt-account-id", HeaderValue::from_static("account-1"));
+        let body = json!({"id": "codex-session-1", "model": "gpt-5.6"});
+
+        let affinity =
+            client_session_affinity_from_api_request("openai:search", &headers, Some(&body))
+                .expect("search affinity should build");
+
+        assert_eq!(affinity.client_family.as_deref(), Some("codex"));
+        assert_eq!(
+            affinity.session_key.as_deref(),
+            Some("account=account-1;session=codex-session-1")
+        );
+    }
+
+    #[test]
+    fn top_level_request_id_is_not_a_generic_session_signal() {
+        let body = json!({"id": "request-id", "model": "gpt-5.6"});
+
+        assert!(client_session_affinity_from_request(&HeaderMap::new(), Some(&body)).is_none());
+    }
 }

apps/aether-gateway/src/constants.rs

@@ -125,6 +125,7 @@ pub(crate) const RUST_FRONTDOOR_OWNED_ROUTE_PATTERNS: &[&str] = &[
     "/v1/messages/count_tokens",
     "/v1/responses",
     "/v1/responses/compact",
+    "/v1/alpha/search",
     "/v1/models/{model}:generateContent",
     "/v1/models/{model}:streamGenerateContent",
     "/v1/models/{model}:predictLongRunning",

apps/aether-gateway/src/control/auth/mod.rs

@@ -6,8 +6,8 @@ mod types;
 
 pub(crate) use credentials::extract_requested_model;
 pub(crate) use gate::{
-    request_model_local_rejection, should_buffer_request_for_local_auth,
-    trusted_auth_local_rejection, GatewayLocalAuthRejection,
+    execution_plan_balance_capacity_rejection, request_model_local_rejection,
+    should_buffer_request_for_local_auth, trusted_auth_local_rejection, GatewayLocalAuthRejection,
 };
 pub(crate) use resolution::{
     refresh_execution_runtime_auth_context, resolve_execution_runtime_auth_context,

apps/aether-gateway/src/control/auth/resolution.rs

@@ -1115,10 +1115,9 @@ fn normalize_api_format_alias(value: &str) -> String {
 
 fn auth_gate_api_format(auth_endpoint_signature: &str) -> String {
     let normalized = normalize_api_format_alias(auth_endpoint_signature);
-    if normalized == "antigravity:v1internal" {
-        "gemini:generate_content".to_string()
-    } else {
-        normalized
+    match normalized.as_str() {
+        "antigravity:v1internal" => "gemini:generate_content".to_string(),
+        _ => normalized,
     }
 }
 

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

@@ -8,7 +8,8 @@ mod public;
 mod route;
 
 pub(crate) use auth::{
-    extract_requested_model, refresh_execution_runtime_auth_context, request_model_local_rejection,
+    execution_plan_balance_capacity_rejection, extract_requested_model,
+    refresh_execution_runtime_auth_context, request_model_local_rejection,
     resolve_execution_runtime_auth_context, should_buffer_request_for_local_auth,
     trusted_auth_local_rejection, GatewayAdminPrincipalContext, GatewayControlAuthContext,
     GatewayLocalAuthRejection,

apps/aether-gateway/src/control/public.rs

@@ -1,59 +1,11 @@
 use axum::http::Uri;
 
-use crate::headers::header_value_str;
 use crate::{AppState, GatewayError};
 
 use super::{resolve_control_route, GatewayControlDecision};
 
-#[derive(Debug, Clone)]
-pub(crate) struct GatewayPublicRequestContext {
-    pub(crate) trace_id: String,
-    pub(crate) request_method: http::Method,
-    pub(crate) request_path: String,
-    pub(crate) request_query_string: Option<String>,
-    pub(crate) request_content_type: Option<String>,
-    pub(crate) host_header: Option<String>,
-    pub(crate) control_decision: Option<GatewayControlDecision>,
-}
-
-impl GatewayPublicRequestContext {
-    pub(crate) fn from_request_parts(
-        trace_id: impl Into<String>,
-        method: &http::Method,
-        uri: &Uri,
-        headers: &http::HeaderMap,
-        control_decision: Option<GatewayControlDecision>,
-    ) -> Self {
-        let request_path = if uri.path().starts_with('/') {
-            uri.path().to_string()
-        } else {
-            format!("/{}", uri.path())
-        };
-        let request_query_string = uri.query().map(ToOwned::to_owned);
-
-        Self {
-            trace_id: trace_id.into(),
-            request_method: method.clone(),
-            request_path,
-            request_query_string,
-            request_content_type: header_value_str(headers, http::header::CONTENT_TYPE.as_str()),
-            host_header: header_value_str(headers, http::header::HOST.as_str()),
-            control_decision,
-        }
-    }
-
-    pub(crate) fn request_path_and_query(&self) -> String {
-        if let Some(query) = self
-            .request_query_string
-            .as_deref()
-            .filter(|value| !value.is_empty())
-        {
-            format!("{}?{query}", self.request_path)
-        } else {
-            self.request_path.clone()
-        }
-    }
-}
+pub(crate) type GatewayPublicRequestContext =
+    aether_gateway_control::PublicRequestContext<GatewayControlDecision>;
 
 pub(crate) async fn resolve_public_request_context(
     state: &AppState,

apps/aether-gateway/src/control/route/ai.rs

@@ -54,6 +54,14 @@ pub(super) fn classify_ai_public_route(
                 true,
             ))
         }
+    } else if method == http::Method::POST && normalized_path == "/v1/alpha/search" {
+        Some(classified(
+            "ai_public",
+            "openai",
+            "search",
+            "openai:search",
+            true,
+        ))
     } else if method == http::Method::POST
         && matches!(
             normalized_path,

apps/aether-gateway/src/control/route/mod.rs

@@ -25,6 +25,7 @@ pub(crate) struct GatewayControlDecision {
     pub(crate) auth_context: Option<GatewayControlAuthContext>,
     pub(crate) admin_principal: Option<GatewayAdminPrincipalContext>,
     pub(crate) local_auth_rejection: Option<GatewayLocalAuthRejection>,
+    pub(crate) model_directive_policy: crate::system_features::ModelDirectivePolicySnapshot,
 }
 
 impl GatewayControlDecision {
@@ -47,6 +48,7 @@ impl GatewayControlDecision {
             auth_context: None,
             admin_principal: None,
             local_auth_rejection: None,
+            model_directive_policy: Default::default(),
         }
     }
 
@@ -131,6 +133,7 @@ impl ClassifiedRoute {
             auth_context: None,
             admin_principal: None,
             local_auth_rejection: None,
+            model_directive_policy: Default::default(),
         }
     }
 }
@@ -146,6 +149,10 @@ pub(crate) async fn resolve_control_route(
         return Ok(None);
     };
     decision.public_query_string = uri.query().map(ToOwned::to_owned);
+    if decision.route_class.as_deref() == Some("ai_public") {
+        decision.model_directive_policy =
+            crate::system_features::ModelDirectivePolicySnapshot::load(state).await;
+    }
 
     match resolve_control_decision_auth(state, headers, uri, trace_id, decision).await? {
         ControlDecisionAuthResolution::Resolved(decision) => Ok(Some(decision)),
@@ -197,6 +204,15 @@ pub(super) fn detect_public_models_auth_signature(uri: &Uri, headers: &http::Hea
         return "gemini:generate_content".to_string();
     }
 
+    let has_codex_client_version = uri.path() == "/v1/models"
+        && uri.query().is_some_and(|query| {
+            url::form_urlencoded::parse(query.as_bytes())
+                .any(|(key, value)| key == "client_version" && !value.trim().is_empty())
+        });
+    if has_codex_client_version {
+        return "openai:responses".to_string();
+    }
+
     if uri.path().starts_with("/v1beta/models") {
         return "gemini:generate_content".to_string();
     }

apps/aether-gateway/src/control/tests/admin_endpoints.rs

@@ -454,6 +454,25 @@ fn classifies_admin_codex_reset_credit_consume_as_admin_proxy_route() {
     assert!(!decision.is_execution_runtime_candidate());
 }
 
+#[test]
+fn admin_codex_reset_credit_consume_buffers_idempotency_key_body() {
+    let headers = headers(&[]);
+    let uri: Uri = "/api/admin/endpoints/keys/key-codex/codex-reset-credit/consume"
+        .parse()
+        .expect("uri should parse");
+    let decision = classify_control_route(&http::Method::POST, &uri, &headers)
+        .expect("decision should resolve");
+    let context = GatewayPublicRequestContext::from_request_parts(
+        "trace-codex-reset-credit-consume",
+        &http::Method::POST,
+        &uri,
+        &headers,
+        Some(decision),
+    );
+
+    assert!(local_proxy_route_requires_buffered_body(&context));
+}
+
 #[test]
 fn admin_refresh_provider_quota_buffers_request_body_for_key_selection() {
     let headers = headers(&[]);

apps/aether-gateway/src/control/tests/ai.rs

@@ -56,6 +56,28 @@ fn classifies_openai_rerank_as_rerank_not_chat() {
     assert!(decision.is_execution_runtime_candidate());
 }
 
+#[test]
+fn classifies_openai_search_as_its_own_sync_endpoint() {
+    let headers = headers(&[("authorization", "Bearer sk-test")]);
+    let uri: Uri = "/v1/alpha/search".parse().expect("uri should parse");
+    let decision =
+        classify_control_route(&http::Method::POST, &uri, &headers).expect("route should classify");
+
+    assert_eq!(decision.route_family.as_deref(), Some("openai"));
+    assert_eq!(decision.route_kind.as_deref(), Some("search"));
+    assert_eq!(
+        decision.auth_endpoint_signature.as_deref(),
+        Some("openai:search")
+    );
+    assert!(decision.is_execution_runtime_candidate());
+    assert!(classify_control_route(&http::Method::GET, &uri, &headers).is_none());
+
+    let upstream_uri: Uri = "/backend-api/codex/alpha/search"
+        .parse()
+        .expect("uri should parse");
+    assert!(classify_control_route(&http::Method::POST, &upstream_uri, &headers).is_none());
+}
+
 #[test]
 fn classifies_openai_chat_and_responses_separately_from_embedding() {
     let headers = headers(&[("authorization", "Bearer sk-test")]);

apps/aether-gateway/src/control/tests/public_support.rs

@@ -20,6 +20,39 @@ fn classifies_models_list_as_public_support_route() {
     assert!(!decision.is_execution_runtime_candidate());
 }
 
+#[test]
+fn classifies_codex_models_list_with_responses_auth_signature() {
+    let headers = headers(&[("authorization", "Bearer sk-test")]);
+    let uri: Uri = "/v1/models?client_version=0.144.1"
+        .parse()
+        .expect("uri should parse");
+    let decision =
+        classify_control_route(&http::Method::GET, &uri, &headers).expect("route should classify");
+
+    assert_eq!(decision.route_class.as_deref(), Some("public_support"));
+    assert_eq!(decision.route_family.as_deref(), Some("models"));
+    assert_eq!(decision.route_kind.as_deref(), Some("list"));
+    assert_eq!(
+        decision.auth_endpoint_signature.as_deref(),
+        Some("openai:responses")
+    );
+}
+
+#[test]
+fn empty_codex_client_version_keeps_standard_openai_models_signature() {
+    let headers = headers(&[("authorization", "Bearer sk-test")]);
+    let uri: Uri = "/v1/models?client_version="
+        .parse()
+        .expect("uri should parse");
+    let decision =
+        classify_control_route(&http::Method::GET, &uri, &headers).expect("route should classify");
+
+    assert_eq!(
+        decision.auth_endpoint_signature.as_deref(),
+        Some("openai:chat")
+    );
+}
+
 #[test]
 fn classifies_v1beta_models_as_gemini_public_support_route() {
     let headers = headers(&[]);

apps/aether-gateway/src/data/candidate_selection.rs

@@ -239,6 +239,29 @@ pub(crate) async fn enumerate_minimal_candidate_selection_with_required_capabili
     auth_snapshot: Option<&GatewayAuthApiKeySnapshot>,
     required_capabilities: Option<&serde_json::Value>,
     enable_model_directives: bool,
+) -> Result<Vec<SchedulerMinimalCandidateSelectionCandidate>, DataLayerError> {
+    enumerate_minimal_candidate_selection_with_required_capabilities_for_request_operation(
+        state,
+        api_format,
+        requested_model_name,
+        require_streaming,
+        auth_snapshot,
+        required_capabilities,
+        enable_model_directives,
+        None,
+    )
+    .await
+}
+
+pub(crate) async fn enumerate_minimal_candidate_selection_with_required_capabilities_for_request_operation(
+    state: &(impl MinimalCandidateSelectionRowSource + Sync),
+    api_format: &str,
+    requested_model_name: &str,
+    require_streaming: bool,
+    auth_snapshot: Option<&GatewayAuthApiKeySnapshot>,
+    required_capabilities: Option<&serde_json::Value>,
+    enable_model_directives: bool,
+    request_operation: Option<&str>,
 ) -> Result<Vec<SchedulerMinimalCandidateSelectionCandidate>, DataLayerError> {
     let normalized_api_format = normalize_api_format(api_format);
     if normalized_api_format.is_empty() {
@@ -267,6 +290,7 @@ pub(crate) async fn enumerate_minimal_candidate_selection_with_required_capabili
         EnumerateMinimalCandidateSelectionInput {
             rows,
             normalized_api_format: &normalized_api_format,
+            request_operation,
             requested_model_name,
             resolved_global_model_name: resolved_global_model_name.as_str(),
             require_streaming,

apps/aether-gateway/src/data/config.rs

@@ -89,4 +89,158 @@ impl GatewayDataConfig {
             postgres: self.postgres.clone(),
         }
     }
+
+    pub(crate) fn split_runtime_pools(&self) -> (Self, Option<Self>) {
+        let configured_background_max =
+            std::env::var("AETHER_GATEWAY_BACKGROUND_DB_MAX_CONNECTIONS")
+                .ok()
+                .and_then(|value| value.trim().parse::<u32>().ok());
+        self.split_runtime_pools_with_background_max(configured_background_max)
+    }
+
+    /// Returns the database capacity reserved for isolated background work, when enabled.
+    pub fn background_database_config(&self) -> Option<SqlDatabaseConfig> {
+        self.split_runtime_pools()
+            .1
+            .and_then(|config| config.database)
+    }
+
+    fn split_runtime_pools_with_background_max(
+        &self,
+        configured_background_max: Option<u32>,
+    ) -> (Self, Option<Self>) {
+        let Some(database) = self.database.as_ref() else {
+            return (self.clone(), None);
+        };
+        let total_max = database.pool.max_connections;
+        if total_max < 2
+            || configured_background_max == Some(0)
+            || is_private_sqlite_memory_database(database)
+        {
+            return (self.clone(), None);
+        }
+
+        let default_background_max = (total_max / 5).clamp(1, 8);
+        let background_max = configured_background_max
+            .unwrap_or(default_background_max)
+            .clamp(1, total_max.saturating_sub(1));
+        let foreground_max = total_max.saturating_sub(background_max).max(1);
+        let total_min = database.pool.min_connections.min(total_max);
+        let background_min = u32::from(total_min > 1).min(background_max);
+        // The configured minimum protects foreground readiness. Isolating background work must
+        // not take one of those warm foreground connections away; the background pool receives
+        // its own single warm connection while the combined hard maximum remains unchanged.
+        let foreground_min = total_min.min(foreground_max);
+
+        (
+            self.with_pool_limits(foreground_min, foreground_max),
+            Some(self.with_pool_limits(background_min, background_max)),
+        )
+    }
+
+    fn with_pool_limits(&self, min_connections: u32, max_connections: u32) -> Self {
+        let mut config = self.clone();
+        if let Some(database) = config.database.as_mut() {
+            database.pool.min_connections = min_connections.min(max_connections);
+            database.pool.max_connections = max_connections;
+        }
+        if let Some(postgres) = config.postgres.as_mut() {
+            postgres.min_connections = min_connections.min(max_connections);
+            postgres.max_connections = max_connections;
+        }
+        config
+    }
+}
+
+fn is_private_sqlite_memory_database(database: &aether_data::SqlDatabaseConfig) -> bool {
+    database.driver == aether_data::DatabaseDriver::Sqlite
+        && matches!(database.url.trim(), "sqlite::memory:" | "sqlite://:memory:")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::GatewayDataConfig;
+    use aether_data::{DatabaseDriver, SqlDatabaseConfig, SqlPoolConfig};
+
+    #[test]
+    fn runtime_pool_split_preserves_total_connection_budget() {
+        let config = GatewayDataConfig::from_database_config(
+            SqlDatabaseConfig::new(
+                DatabaseDriver::Postgres,
+                "postgres://localhost/aether",
+                SqlPoolConfig {
+                    min_connections: 4,
+                    max_connections: 20,
+                    ..SqlPoolConfig::default()
+                },
+            )
+            .expect("database config should be valid"),
+        );
+
+        let (foreground, background) = config.split_runtime_pools_with_background_max(Some(4));
+        let foreground = foreground.database().expect("foreground database");
+        let background = background
+            .expect("background database config")
+            .database()
+            .expect("background database")
+            .clone();
+
+        assert_eq!(foreground.pool.max_connections, 16);
+        assert_eq!(background.pool.max_connections, 4);
+        assert_eq!(
+            foreground.pool.max_connections + background.pool.max_connections,
+            20
+        );
+        assert_eq!(foreground.pool.min_connections, 4);
+        assert_eq!(background.pool.min_connections, 1);
+    }
+
+    #[test]
+    fn runtime_pool_split_can_be_disabled_or_degrade_for_single_connection() {
+        let mut database = SqlDatabaseConfig::sqlite_default();
+        database.pool.max_connections = 1;
+        let config = GatewayDataConfig::from_database_config(database);
+        assert!(config
+            .split_runtime_pools_with_background_max(Some(1))
+            .1
+            .is_none());
+
+        let mut database = SqlDatabaseConfig::sqlite_default();
+        database.pool.max_connections = 8;
+        let config = GatewayDataConfig::from_database_config(database);
+        assert!(config
+            .split_runtime_pools_with_background_max(Some(0))
+            .1
+            .is_none());
+    }
+
+    #[test]
+    fn runtime_pool_split_keeps_private_sqlite_memory_database_in_one_pool() {
+        for url in ["sqlite::memory:", "sqlite://:memory:"] {
+            let config = GatewayDataConfig::from_database_config(
+                SqlDatabaseConfig::new(
+                    DatabaseDriver::Sqlite,
+                    url,
+                    SqlPoolConfig {
+                        min_connections: 1,
+                        max_connections: 8,
+                        ..SqlPoolConfig::default()
+                    },
+                )
+                .expect("sqlite memory database config should be valid"),
+            );
+
+            let (foreground, background) = config.split_runtime_pools_with_background_max(Some(2));
+
+            assert!(background.is_none(), "private SQLite URL {url} was split");
+            assert_eq!(
+                foreground
+                    .database()
+                    .expect("foreground database")
+                    .pool
+                    .max_connections,
+                8
+            );
+        }
+    }
 }

apps/aether-gateway/src/data/state/auth.rs

@@ -12,10 +12,7 @@ use super::{
     StoredWalletSnapshot, UpdateManagementTokenRecord, UpsertOAuthProviderConfigRecord,
 };
 use crate::LocalMutationOutcome;
-use aether_data::repository::auth::{
-    read_resolved_auth_api_key_snapshot_by_key_hash,
-    read_resolved_auth_api_key_snapshot_by_user_api_key_ids,
-};
+use aether_data::repository::auth::ResolvedAuthApiKeySnapshotReader;
 
 #[derive(Debug, Clone, Default)]
 pub(crate) struct GatewayUserEffectiveListPolicies {
@@ -1751,15 +1748,14 @@ impl GatewayDataState {
         let snapshot = crate::request_diagnostics::observe_db_operation(
             "auth_api_key_snapshot",
             self.database_pool_summary(),
-            read_resolved_auth_api_key_snapshot_by_user_api_key_ids(
-                self,
+            self.find_stored_auth_api_key_snapshot(AuthApiKeyLookupKey::UserApiKeyIds {
                 user_id,
                 api_key_id,
-                now_unix_secs,
-            ),
+            }),
         )
         .await?;
-        self.apply_user_group_effective_policies(snapshot).await
+        self.apply_user_group_effective_policies(snapshot, now_unix_secs)
+            .await
     }
 
     pub(crate) async fn read_auth_api_key_snapshot_by_key_hash(
@@ -1770,25 +1766,33 @@ impl GatewayDataState {
         let snapshot = crate::request_diagnostics::observe_db_operation(
             "auth_api_key_snapshot_by_hash",
             self.database_pool_summary(),
-            read_resolved_auth_api_key_snapshot_by_key_hash(self, key_hash, now_unix_secs),
+            self.find_stored_auth_api_key_snapshot(AuthApiKeyLookupKey::KeyHash(key_hash)),
         )
         .await?;
-        self.apply_user_group_effective_policies(snapshot).await
+        self.apply_user_group_effective_policies(snapshot, now_unix_secs)
+            .await
     }
 
     async fn apply_user_group_effective_policies(
         &self,
-        snapshot: Option<GatewayAuthApiKeySnapshot>,
+        snapshot: Option<StoredAuthApiKeySnapshot>,
+        now_unix_secs: u64,
     ) -> Result<Option<GatewayAuthApiKeySnapshot>, DataLayerError> {
         let Some(mut snapshot) = snapshot else {
             return Ok(None);
         };
         if snapshot.user_role.eq_ignore_ascii_case("admin") && !snapshot.api_key_is_standalone {
             apply_admin_unrestricted_auth_snapshot(&mut snapshot);
-            return Ok(Some(snapshot));
+            return Ok(Some(GatewayAuthApiKeySnapshot::from_stored(
+                snapshot,
+                now_unix_secs,
+            )));
         }
         let Some(repository) = self.user_reader.as_ref() else {
-            return Ok(Some(snapshot));
+            return Ok(Some(GatewayAuthApiKeySnapshot::from_stored(
+                snapshot,
+                now_unix_secs,
+            )));
         };
         let Some(user) = crate::request_diagnostics::observe_db_operation(
             "auth_user_policy",
@@ -1797,57 +1801,37 @@ impl GatewayDataState {
         )
         .await?
         else {
-            return Ok(Some(snapshot));
+            return Ok(Some(GatewayAuthApiKeySnapshot::from_stored(
+                snapshot,
+                now_unix_secs,
+            )));
         };
         if user.role.eq_ignore_ascii_case("admin") && !snapshot.api_key_is_standalone {
             snapshot.user_role = user.role;
             apply_admin_unrestricted_auth_snapshot(&mut snapshot);
-            return Ok(Some(snapshot));
+            return Ok(Some(GatewayAuthApiKeySnapshot::from_stored(
+                snapshot,
+                now_unix_secs,
+            )));
         }
         let groups = self
             .effective_user_groups_for_user(&snapshot.user_id)
             .await?;
 
-        let mut allowed_providers =
-            resolve_effective_list_policy(None, "unrestricted", &groups, |group| {
-                (
-                    &group.allowed_providers_mode,
-                    group.allowed_providers.clone(),
-                )
-            });
-        let mut allowed_api_formats =
-            resolve_effective_list_policy(None, "unrestricted", &groups, |group| {
-                (
-                    &group.allowed_api_formats_mode,
-                    group.allowed_api_formats.clone(),
-                )
-            });
-        let mut allowed_models =
-            resolve_effective_list_policy(None, "unrestricted", &groups, |group| {
-                (&group.allowed_models_mode, group.allowed_models.clone())
-            });
-        let user_rate_limit = resolve_effective_rate_limit_policy(None, "system", &groups);
-        if !snapshot.api_key_is_standalone {
-            constrain_api_key_list_policy_to_user_policy(
-                &mut allowed_providers,
-                &mut snapshot.api_key_allowed_providers,
-            );
-            constrain_api_key_list_policy_to_user_policy(
-                &mut allowed_api_formats,
-                &mut snapshot.api_key_allowed_api_formats,
-            );
-            constrain_api_key_list_policy_to_user_policy(
-                &mut allowed_models,
-                &mut snapshot.api_key_allowed_models,
-            );
-        }
-        snapshot.apply_user_policy(
+        let GatewayUserEffectiveListPolicies {
             allowed_providers,
             allowed_api_formats,
             allowed_models,
-            user_rate_limit,
-        );
-        Ok(Some(snapshot))
+        } = resolve_group_effective_list_policies(&groups);
+        let user_rate_limit = resolve_effective_rate_limit_policy(None, "system", &groups);
+        snapshot.user_allowed_providers = allowed_providers;
+        snapshot.user_allowed_api_formats = allowed_api_formats;
+        snapshot.user_allowed_models = allowed_models;
+        snapshot.user_rate_limit = user_rate_limit;
+        Ok(Some(GatewayAuthApiKeySnapshot::from_stored(
+            snapshot,
+            now_unix_secs,
+        )))
     }
 
     pub(crate) async fn resolve_user_effective_list_policies(
@@ -1863,36 +1847,7 @@ impl GatewayDataState {
         } else {
             Vec::new()
         };
-        Ok(GatewayUserEffectiveListPolicies {
-            allowed_providers: resolve_effective_list_policy(
-                user.allowed_providers.clone(),
-                &user.allowed_providers_mode,
-                &groups,
-                |group| {
-                    (
-                        &group.allowed_providers_mode,
-                        group.allowed_providers.clone(),
-                    )
-                },
-            ),
-            allowed_api_formats: resolve_effective_list_policy(
-                user.allowed_api_formats.clone(),
-                &user.allowed_api_formats_mode,
-                &groups,
-                |group| {
-                    (
-                        &group.allowed_api_formats_mode,
-                        group.allowed_api_formats.clone(),
-                    )
-                },
-            ),
-            allowed_models: resolve_effective_list_policy(
-                user.allowed_models.clone(),
-                &user.allowed_models_mode,
-                &groups,
-                |group| (&group.allowed_models_mode, group.allowed_models.clone()),
-            ),
-        })
+        Ok(resolve_group_effective_list_policies(&groups))
     }
 
     async fn effective_user_groups_for_user(
@@ -1970,7 +1925,7 @@ impl GatewayDataState {
     }
 }
 
-fn apply_admin_unrestricted_auth_snapshot(snapshot: &mut GatewayAuthApiKeySnapshot) {
+fn apply_admin_unrestricted_auth_snapshot(snapshot: &mut StoredAuthApiKeySnapshot) {
     snapshot.user_allowed_providers = None;
     snapshot.user_allowed_api_formats = None;
     snapshot.user_allowed_models = None;
@@ -1982,6 +1937,35 @@ fn apply_admin_unrestricted_auth_snapshot(snapshot: &mut GatewayAuthApiKeySnapsh
     snapshot.api_key_concurrent_limit = None;
 }
 
+// Per-user list policy columns are retained only for legacy import/export compatibility.
+// Runtime authorization and user-facing catalogs must both treat group policies as authoritative.
+fn resolve_group_effective_list_policies(
+    groups: &[aether_data::repository::users::StoredUserGroup],
+) -> GatewayUserEffectiveListPolicies {
+    GatewayUserEffectiveListPolicies {
+        allowed_providers: resolve_effective_list_policy(None, "unrestricted", groups, |group| {
+            (
+                &group.allowed_providers_mode,
+                group.allowed_providers.clone(),
+            )
+        }),
+        allowed_api_formats: resolve_effective_api_format_policy(
+            None,
+            "unrestricted",
+            groups,
+            |group| {
+                (
+                    &group.allowed_api_formats_mode,
+                    group.allowed_api_formats.clone(),
+                )
+            },
+        ),
+        allowed_models: resolve_effective_list_policy(None, "unrestricted", groups, |group| {
+            (&group.allowed_models_mode, group.allowed_models.clone())
+        }),
+    }
+}
+
 fn resolve_effective_list_policy(
     user_values: Option<Vec<String>>,
     user_mode: &str,
@@ -1995,6 +1979,19 @@ fn resolve_effective_list_policy(
     intersect_list_policies(group_policy, user_policy)
 }
 
+fn resolve_effective_api_format_policy(
+    user_values: Option<Vec<String>>,
+    user_mode: &str,
+    groups: &[aether_data::repository::users::StoredUserGroup],
+    group_field: impl Fn(
+        &aether_data::repository::users::StoredUserGroup,
+    ) -> (&str, Option<Vec<String>>),
+) -> Option<Vec<String>> {
+    let group_policy = union_group_list_policies(groups, group_field);
+    let user_policy = list_restriction_from_mode(user_mode, user_values);
+    intersect_api_format_list_policies(group_policy, user_policy)
+}
+
 fn union_group_list_policies(
     groups: &[aether_data::repository::users::StoredUserGroup],
     group_field: impl Fn(
@@ -2089,6 +2086,19 @@ fn intersect_list_policies(
     }
 }
 
+fn intersect_api_format_list_policies(
+    left: Option<Vec<String>>,
+    right: Option<Vec<String>>,
+) -> Option<Vec<String>> {
+    match (left, right) {
+        (None, None) => None,
+        (Some(values), None) | (None, Some(values)) => Some(values),
+        (Some(left_values), Some(right_values)) => Some(
+            crate::ai_serving::intersect_api_format_allowed_lists(&left_values, &right_values),
+        ),
+    }
+}
+
 fn intersect_rate_limit_policies(
     left: Option<RateLimitRestriction>,
     right: Option<RateLimitRestriction>,
@@ -2133,22 +2143,6 @@ fn rate_limit_policy_value(policy: Option<RateLimitRestriction>) -> Option<i32>
     }
 }
 
-fn constrain_api_key_list_policy_to_user_policy(
-    user_policy: &mut Option<Vec<String>>,
-    api_key_policy: &mut Option<Vec<String>>,
-) {
-    let Some(api_key_values) = api_key_policy.as_ref().filter(|values| !values.is_empty()) else {
-        return;
-    };
-    let Some(user_values) = user_policy.clone() else {
-        return;
-    };
-    let effective = intersect_list_policies(Some(api_key_values.to_vec()), Some(user_values))
-        .unwrap_or_default();
-    *user_policy = Some(effective.clone());
-    *api_key_policy = Some(effective);
-}
-
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;
@@ -2279,6 +2273,41 @@ mod tests {
         );
     }
 
+    #[test]
+    fn api_format_policy_intersection_preserves_search_companion_scope() {
+        let mut responses_group =
+            sample_group("responses", 10, None, "unrestricted", None, "system");
+        responses_group.allowed_api_formats = Some(vec!["openai:responses".to_string()]);
+        responses_group.allowed_api_formats_mode = "specific".to_string();
+
+        let search_policy = resolve_effective_api_format_policy(
+            Some(vec!["openai:search".to_string()]),
+            "specific",
+            std::slice::from_ref(&responses_group),
+            |group| {
+                (
+                    &group.allowed_api_formats_mode,
+                    group.allowed_api_formats.clone(),
+                )
+            },
+        );
+        assert_eq!(search_policy, Some(vec!["openai:search".to_string()]));
+
+        responses_group.allowed_api_formats = Some(vec!["openai:search".to_string()]);
+        let responses_policy = resolve_effective_api_format_policy(
+            Some(vec!["openai:responses".to_string()]),
+            "specific",
+            &[responses_group],
+            |group| {
+                (
+                    &group.allowed_api_formats_mode,
+                    group.allowed_api_formats.clone(),
+                )
+            },
+        );
+        assert_eq!(responses_policy, Some(vec!["openai:search".to_string()]));
+    }
+
     #[test]
     fn list_policy_unions_multiple_group_restrictions_legacy_case() {
         let groups = vec![
@@ -2452,17 +2481,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn api_key_specific_policy_cannot_expand_user_policy() {
-        let mut user_policy = Some(vec!["gpt-5".to_string()]);
-        let mut api_key_policy = Some(vec!["gpt-4.1".to_string()]);
-
-        constrain_api_key_list_policy_to_user_policy(&mut user_policy, &mut api_key_policy);
-
-        assert_eq!(user_policy, Some(Vec::<String>::new()));
-        assert_eq!(api_key_policy, Some(Vec::<String>::new()));
-    }
-
     #[tokio::test]
     async fn admin_non_standalone_snapshot_bypasses_group_and_key_policies() {
         let mut snapshot = sample_snapshot_with_role("key-admin", "admin-1", "admin")
@@ -2518,6 +2536,38 @@ mod tests {
         assert_eq!(resolved.api_key_concurrent_limit, None);
     }
 
+    #[tokio::test]
+    async fn current_admin_role_bypasses_stored_user_and_key_policies() {
+        let mut snapshot = sample_snapshot("key-admin", "admin-1");
+        snapshot.api_key_allowed_providers = Some(vec!["anthropic".to_string()]);
+        snapshot.api_key_allowed_api_formats = Some(vec!["anthropic:messages".to_string()]);
+        snapshot.api_key_allowed_models = Some(vec!["claude-sonnet-4-5".to_string()]);
+
+        let auth_repository = Arc::new(InMemoryAuthApiKeySnapshotRepository::seed(vec![(
+            Some("hash-admin".to_string()),
+            snapshot,
+        )]));
+        let user_repository = Arc::new(InMemoryUserReadRepository::seed_auth_users(vec![
+            sample_auth_user("admin-1", "admin"),
+        ]));
+        let state = GatewayDataState::with_auth_api_key_reader_for_tests(auth_repository)
+            .with_user_reader(user_repository);
+
+        let resolved = state
+            .read_auth_api_key_snapshot_by_key_hash("hash-admin", 100)
+            .await
+            .expect("snapshot should resolve")
+            .expect("snapshot should exist");
+
+        assert_eq!(resolved.user_role, "admin");
+        assert_eq!(resolved.effective_allowed_providers(), None);
+        assert_eq!(resolved.effective_allowed_api_formats(), None);
+        assert_eq!(resolved.effective_allowed_models(), None);
+        assert_eq!(resolved.user_rate_limit, None);
+        assert_eq!(resolved.api_key_rate_limit, None);
+        assert_eq!(resolved.api_key_concurrent_limit, None);
+    }
+
     #[tokio::test]
     async fn user_personal_policy_fields_are_ignored_when_groups_are_applied() {
         let mut snapshot = sample_snapshot("key-user", "user-1").with_user_rate_limit(Some(200));
@@ -2529,8 +2579,9 @@ mod tests {
             Some("hash-user".to_string()),
             snapshot,
         )]));
+        let user = sample_auth_user("user-1", "user");
         let user_repository = Arc::new(InMemoryUserReadRepository::seed_auth_users(vec![
-            sample_auth_user("user-1", "user"),
+            user.clone()
         ]));
         let group = user_repository
             .create_user_group(UpsertUserGroupRecord {
@@ -2575,6 +2626,110 @@ mod tests {
             Some(&["claude-sonnet-4-5".to_string()][..])
         );
         assert_eq!(resolved.user_rate_limit, Some(30));
+
+        let catalog_policies = state
+            .resolve_user_effective_list_policies(&user)
+            .await
+            .expect("catalog policies should resolve");
+        assert_eq!(
+            catalog_policies.allowed_providers.as_deref(),
+            resolved.effective_allowed_providers()
+        );
+        assert_eq!(
+            catalog_policies.allowed_api_formats.as_deref(),
+            resolved.effective_allowed_api_formats()
+        );
+        assert_eq!(
+            catalog_policies.allowed_models.as_deref(),
+            resolved.effective_allowed_models()
+        );
+    }
+
+    #[tokio::test]
+    async fn group_responses_permission_and_key_search_scope_resolve_to_search() {
+        let mut snapshot = sample_snapshot("key-search", "user-search");
+        snapshot.api_key_allowed_api_formats = Some(vec!["openai:search".to_string()]);
+        let auth_repository = Arc::new(InMemoryAuthApiKeySnapshotRepository::seed(vec![(
+            Some("hash-search".to_string()),
+            snapshot,
+        )]));
+        let user_repository = Arc::new(InMemoryUserReadRepository::seed_auth_users(vec![
+            sample_auth_user("user-search", "user"),
+        ]));
+        let group = user_repository
+            .create_user_group(UpsertUserGroupRecord {
+                name: "Responses".to_string(),
+                description: None,
+                priority: 10,
+                allowed_providers: None,
+                allowed_providers_mode: "unrestricted".to_string(),
+                allowed_api_formats: Some(vec!["openai:responses".to_string()]),
+                allowed_api_formats_mode: "specific".to_string(),
+                allowed_models: None,
+                allowed_models_mode: "unrestricted".to_string(),
+                rate_limit: None,
+                rate_limit_mode: "system".to_string(),
+            })
+            .await
+            .expect("group should create")
+            .expect("group should exist");
+        user_repository
+            .add_user_to_group(&group.id, "user-search")
+            .await
+            .expect("group membership should create");
+
+        let state = GatewayDataState::with_auth_api_key_reader_for_tests(auth_repository)
+            .with_user_reader(user_repository);
+        let resolved = state
+            .read_auth_api_key_snapshot_by_key_hash("hash-search", 100)
+            .await
+            .expect("snapshot should resolve")
+            .expect("snapshot should exist");
+
+        assert_eq!(
+            resolved.effective_allowed_api_formats(),
+            Some(&["openai:search".to_string()][..])
+        );
+    }
+
+    #[tokio::test]
+    async fn snapshot_without_user_reader_uses_stored_policy_intersection() {
+        let mut snapshot = sample_snapshot("key-search", "user-search");
+        snapshot.api_key_allowed_api_formats = Some(vec!["openai:search".to_string()]);
+        let auth_repository = Arc::new(InMemoryAuthApiKeySnapshotRepository::seed(vec![(
+            Some("hash-search".to_string()),
+            snapshot,
+        )]));
+        let state = GatewayDataState::with_auth_api_key_reader_for_tests(auth_repository);
+
+        let resolved = state
+            .read_auth_api_key_snapshot_by_key_hash("hash-search", 100)
+            .await
+            .expect("snapshot should resolve")
+            .expect("snapshot should exist");
+
+        assert_eq!(resolved.effective_allowed_api_formats(), Some(&[][..]));
+    }
+
+    #[tokio::test]
+    async fn missing_current_user_uses_stored_policy_intersection() {
+        let mut snapshot = sample_snapshot("key-search", "missing-user");
+        snapshot.api_key_allowed_api_formats = Some(vec!["openai:search".to_string()]);
+        let auth_repository = Arc::new(InMemoryAuthApiKeySnapshotRepository::seed(vec![(
+            Some("hash-search".to_string()),
+            snapshot,
+        )]));
+        let user_repository = Arc::new(InMemoryUserReadRepository::default());
+        let state = GatewayDataState::with_auth_api_key_reader_for_tests(auth_repository)
+            .with_user_reader(user_repository);
+
+        let resolved = state
+            .read_auth_api_key_snapshot_by_key_hash("hash-search", 100)
+            .await
+            .expect("snapshot should resolve")
+            .expect("snapshot should exist");
+
+        assert_eq!(resolved.effective_allowed_api_formats(), Some(&[][..]));
     }
 
     #[tokio::test]

apps/aether-gateway/src/data/state/catalog.rs

@@ -546,6 +546,88 @@ impl GatewayDataState {
         Ok(updated)
     }
 
+    pub(crate) async fn upsert_provider_catalog_key_upstream_metadata_namespace(
+        &self,
+        key_id: &str,
+        namespace: &str,
+        value: &serde_json::Value,
+        updated_at_unix_secs: Option<u64>,
+    ) -> Result<bool, DataLayerError> {
+        let updated = match &self.provider_catalog_writer {
+            Some(repository) => {
+                repository
+                    .upsert_key_upstream_metadata_namespace(
+                        key_id,
+                        namespace,
+                        value,
+                        updated_at_unix_secs,
+                    )
+                    .await
+            }
+            None => Ok(false),
+        }?;
+        if updated {
+            self.clear_provider_catalog_cache();
+        }
+        Ok(updated)
+    }
+
+    pub(crate) async fn update_provider_catalog_key_model_fetch_state(
+        &self,
+        key_id: &str,
+        allowed_models: Option<&serde_json::Value>,
+        last_models_fetch_at_unix_secs: Option<u64>,
+        last_models_fetch_error: Option<&str>,
+        updated_at_unix_secs: Option<u64>,
+    ) -> Result<bool, DataLayerError> {
+        let updated = match &self.provider_catalog_writer {
+            Some(repository) => {
+                repository
+                    .update_key_model_fetch_state(
+                        key_id,
+                        allowed_models,
+                        last_models_fetch_at_unix_secs,
+                        last_models_fetch_error,
+                        updated_at_unix_secs,
+                    )
+                    .await
+            }
+            None => Ok(false),
+        }?;
+        if updated {
+            self.clear_provider_catalog_cache();
+        }
+        Ok(updated)
+    }
+
+    pub(crate) async fn update_provider_catalog_key_model_fetch_success(
+        &self,
+        key_id: &str,
+        allowed_models: Option<&serde_json::Value>,
+        last_models_fetch_at_unix_secs: u64,
+        upstream_metadata_updates: &[aether_data_contracts::repository::provider_catalog::ProviderCatalogUpstreamMetadataNamespaceUpdate],
+        updated_at_unix_secs: Option<u64>,
+    ) -> Result<bool, DataLayerError> {
+        let updated = match &self.provider_catalog_writer {
+            Some(repository) => {
+                repository
+                    .update_key_model_fetch_success(
+                        key_id,
+                        allowed_models,
+                        last_models_fetch_at_unix_secs,
+                        upstream_metadata_updates,
+                        updated_at_unix_secs,
+                    )
+                    .await
+            }
+            None => Ok(false),
+        }?;
+        if updated {
+            self.clear_provider_catalog_cache();
+        }
+        Ok(updated)
+    }
+
     pub(crate) async fn delete_provider_catalog_key(
         &self,
         key_id: &str,

apps/aether-gateway/src/data/state/runtime.rs

@@ -38,7 +38,8 @@ use aether_data_contracts::repository::usage::{
     PendingUsageCleanupSummary, ProviderApiKeyWindowUsageRequest,
     StoredProviderApiKeyWindowUsageSummary, StoredUsageDailySummary, UsageAuditListQuery,
     UsageCleanupExecutionMode, UsageCleanupSummary, UsageCleanupTargets, UsageCleanupWindow,
-    UsageCounterFlushSummary, UsageCounterHealthSnapshot, UsageDailyHeatmapQuery,
+    UsageCounterFlushSummary, UsageCounterHealthSnapshot, UsageCounterPendingHealthSnapshot,
+    UsageDailyHeatmapQuery,
 };
 use aether_runtime_state::RuntimeQueueStore;
 use aether_video_tasks_core::read_data_backed_video_task_response;
@@ -152,6 +153,13 @@ impl GatewayDataState {
         }
     }
 
+    pub(crate) async fn warm_database_pool(&self) -> Result<(), DataLayerError> {
+        match &self.backends {
+            Some(backends) => backends.warm_database_pool().await,
+            None => Ok(()),
+        }
+    }
+
     pub(crate) async fn pending_database_backfills(
         &self,
     ) -> Result<
@@ -198,15 +206,22 @@ impl GatewayDataState {
     pub(crate) fn database_pool_summary_under_maintenance_pressure(
         summary: &aether_data::DatabasePoolSummary,
     ) -> bool {
-        summary.checked_out > 0 && summary.idle <= Self::maintenance_pool_idle_reserve(summary)
+        summary.checked_out > 0
+            && Self::database_pool_available_capacity(summary)
+                <= Self::maintenance_pool_idle_reserve(summary)
     }
 
     pub(crate) fn database_pool_summary_under_usage_worker_pressure(
         summary: &aether_data::DatabasePoolSummary,
     ) -> bool {
         summary.checked_out > 0
-            && (summary.checked_out >= summary.max_connections as usize
-                || summary.idle <= Self::usage_worker_pool_idle_reserve(summary))
+            && Self::database_pool_available_capacity(summary)
+                <= Self::usage_worker_pool_idle_reserve(summary)
+    }
+
+    fn database_pool_available_capacity(summary: &aether_data::DatabasePoolSummary) -> usize {
+        let unopened = (summary.max_connections as usize).saturating_sub(summary.pool_size);
+        summary.idle.saturating_add(unopened)
     }
 
     pub(crate) fn maintenance_pool_idle_reserve(
@@ -1353,6 +1368,15 @@ impl GatewayDataState {
         }
     }
 
+    pub(crate) async fn read_usage_counter_pending_health(
+        &self,
+    ) -> Result<UsageCounterPendingHealthSnapshot, DataLayerError> {
+        match &self.usage_reader {
+            Some(repository) => repository.read_usage_counter_pending_health().await,
+            None => Ok(UsageCounterPendingHealthSnapshot::default()),
+        }
+    }
+
     pub(crate) async fn summarize_usage_totals_by_user_ids(
         &self,
         user_ids: &[String],
@@ -1439,6 +1463,22 @@ impl GatewayDataState {
         }
     }
 
+    pub(crate) async fn summarize_dashboard_stats(
+        &self,
+        query: &aether_data_contracts::repository::usage::UsageDashboardSummaryQuery,
+    ) -> Result<
+        aether_data_contracts::repository::usage::StoredUsageDashboardStatsSummary,
+        DataLayerError,
+    > {
+        match &self.usage_reader {
+            Some(repository) => repository.summarize_dashboard_stats(query).await,
+            None => Ok(
+                aether_data_contracts::repository::usage::StoredUsageDashboardStatsSummary::default(
+                ),
+            ),
+        }
+    }
+
     pub(crate) async fn list_dashboard_daily_breakdown(
         &self,
         query: &aether_data_contracts::repository::usage::UsageDashboardDailyBreakdownQuery,

apps/aether-gateway/src/data/tests.rs

@@ -54,7 +54,7 @@ fn disabled_gateway_data_state_has_no_backends() {
 
 #[test]
 fn maintenance_pool_pressure_keeps_idle_reserve_for_foreground_work() {
-    let pressured = aether_data::DatabasePoolSummary {
+    let pool_can_still_grow = aether_data::DatabasePoolSummary {
         driver: DatabaseDriver::Postgres,
         checked_out: 6,
         pool_size: 6,
@@ -62,7 +62,9 @@ fn maintenance_pool_pressure_keeps_idle_reserve_for_foreground_work() {
         max_connections: 20,
         usage_rate: 30.0,
     };
-    assert!(GatewayDataState::database_pool_summary_under_maintenance_pressure(&pressured));
+    assert!(
+        !GatewayDataState::database_pool_summary_under_maintenance_pressure(&pool_can_still_grow)
+    );
 
     let reserve_idle_left = aether_data::DatabasePoolSummary {
         driver: DatabaseDriver::Postgres,
@@ -588,6 +590,7 @@ fn sample_minimal_candidate_selection_row(
             priority: 1,
             api_formats: Some(vec!["openai:chat".to_string()]),
             endpoint_ids: None,
+            operations: None,
         }]),
         model_supports_streaming: None,
         model_is_active: true,
@@ -905,6 +908,7 @@ async fn data_state_reads_minimal_candidate_selection_with_auth_filters() {
         enumerate_minimal_candidate_selection(EnumerateMinimalCandidateSelectionInput {
             rows,
             normalized_api_format: "openai:chat",
+            request_operation: None,
             requested_model_name: "gpt-4.1",
             resolved_global_model_name: "gpt-4.1",
             require_streaming: false,

apps/aether-gateway/src/dispatch/pool_scheduler.rs

@@ -4172,6 +4172,7 @@ mod tests {
                 global_model_id: "global-model-1".to_string(),
                 global_model_name: "gpt-5".to_string(),
                 selected_provider_model_name: "gpt-5".to_string(),
+                supports_streaming: true,
                 mapping_matched_model: None,
             },
             provider_api_format: "openai:responses".to_string(),
@@ -4285,6 +4286,7 @@ mod tests {
                 global_model_id: "global-model-1".to_string(),
                 global_model_name: "gpt-5".to_string(),
                 selected_provider_model_name: "gpt-5".to_string(),
+                supports_streaming: true,
                 mapping_matched_model: None,
             },
             provider_api_format: "openai:chat".to_string(),

apps/aether-gateway/src/dispatch/refs.rs

@@ -146,6 +146,7 @@ mod tests {
                 global_model_id: "global-model-1".to_string(),
                 global_model_name: "gpt-5".to_string(),
                 selected_provider_model_name: "gpt-5".to_string(),
+                supports_streaming: true,
                 mapping_matched_model: None,
             },
             transport: Arc::new(crate::ai_serving::GatewayProviderTransportSnapshot {

apps/aether-gateway/src/execution_runtime/constants.rs

@@ -1,3 +1,5 @@
-pub(crate) const MAX_ERROR_BODY_BYTES: usize = 16_384;
-pub(crate) const MAX_STREAM_PREFETCH_FRAMES: usize = 5;
-pub(crate) const MAX_STREAM_PREFETCH_BYTES: usize = 16_384;
+//! Compatibility facade for execution resource limits.
+
+pub(crate) use aether_gateway_execution::{
+    MAX_ERROR_BODY_BYTES, MAX_STREAM_PREFETCH_BYTES, MAX_STREAM_PREFETCH_FRAMES,
+};

apps/aether-gateway/src/execution_runtime/fallback.rs

@@ -941,6 +941,7 @@ mod tests {
                 success_failover_patterns: Vec::new(),
                 error_stop_patterns: Vec::new(),
                 stop_cyber_policy_errors: false,
+                retry_client_errors_by_default: true,
             }
         );
     }

apps/aether-gateway/src/execution_runtime/grok.rs

@@ -1042,6 +1042,7 @@ fn grok_stream_terminal_summary(
         finish_reason: Some("stop".to_string()),
         response_id: None,
         model: plan.model_name.clone(),
+        provider_actual_service_tier: None,
         observed_finish: true,
         unknown_event_count: 0,
         parser_error: None,

apps/aether-gateway/src/execution_runtime/ndjson.rs

@@ -1,3 +1,5 @@
+//! Compatibility facade for execution stream framing.
+
 use std::io::Error as IoError;
 
 use aether_contracts::StreamFrame;
@@ -6,36 +8,10 @@ use axum::body::Bytes;
 use crate::GatewayError;
 
 pub(crate) fn encode_stream_frame_ndjson(frame: &StreamFrame) -> Result<Bytes, IoError> {
-    let mut raw = serde_json::to_vec(frame).map_err(|err| IoError::other(err.to_string()))?;
-    raw.push(b'\n');
-    Ok(Bytes::from(raw))
+    aether_gateway_execution::stream::encode_stream_frame_ndjson(frame)
 }
 
 pub(crate) fn decode_stream_frame_ndjson(line: &[u8]) -> Result<StreamFrame, GatewayError> {
-    serde_json::from_slice(line).map_err(|err| GatewayError::Internal(err.to_string()))
-}
-
-#[cfg(test)]
-mod tests {
-    use std::collections::BTreeMap;
-
-    use aether_contracts::{StreamFramePayload, StreamFrameType};
-
-    use super::{decode_stream_frame_ndjson, encode_stream_frame_ndjson};
-
-    #[test]
-    fn ndjson_round_trip_preserves_frame() {
-        let frame = aether_contracts::StreamFrame {
-            frame_type: StreamFrameType::Headers,
-            payload: StreamFramePayload::Headers {
-                status_code: 200,
-                headers: BTreeMap::from([("content-type".into(), "text/event-stream".into())]),
-            },
-        };
-
-        let raw = encode_stream_frame_ndjson(&frame).expect("frame should encode");
-        let decoded =
-            decode_stream_frame_ndjson(raw.trim_ascii_end()).expect("frame should decode");
-        assert_eq!(decoded, frame);
-    }
+    aether_gateway_execution::stream::decode_stream_frame_ndjson(line)
+        .map_err(|err| GatewayError::Internal(err.to_string()))
 }

apps/aether-gateway/src/execution_runtime/server.rs

@@ -359,8 +359,7 @@ impl IntoResponse for ExecutionRuntimeAppError {
                 return build_overloaded_response(&self.0.to_string());
             }
             ExecutionRuntimeServerError::Transport(
-                ExecutionRuntimeTransportError::StreamUnsupported
-                | ExecutionRuntimeTransportError::RequestBodyRequired
+                ExecutionRuntimeTransportError::RequestBodyRequired
                 | ExecutionRuntimeTransportError::BodyDecode(_)
                 | ExecutionRuntimeTransportError::UnsupportedContentEncoding(_)
                 | ExecutionRuntimeTransportError::ProxyUnsupported
@@ -397,7 +396,9 @@ mod tests {
         build_execution_runtime_router_with_request_concurrency_limit,
         build_execution_runtime_router_with_request_gates, DISTRIBUTED_REQUEST_GATE_NAME,
     };
-    use aether_contracts::{ExecutionPlan, ExecutionTimeouts, RequestBody};
+    use aether_contracts::{
+        ExecutionPlan, ExecutionTimeouts, RequestBody, StreamFrame, StreamFrameType,
+    };
     use aether_runtime_state::{
         MemoryRuntimeStateConfig, RuntimeSemaphore, RuntimeSemaphoreConfig, RuntimeState,
     };
@@ -459,6 +460,43 @@ mod tests {
         }
     }
 
+    #[tokio::test]
+    async fn execution_runtime_stream_endpoint_carries_non_stream_upstream_plan() {
+        let upstream = Router::new().route(
+            "/sync-json",
+            any(|| async { axum::Json(serde_json::json!({"ok": true})) }),
+        );
+        let (upstream_url, upstream_handle) = start_server(upstream).await;
+        let runtime = build_execution_runtime_router_with_request_concurrency_limit(None);
+        let (runtime_url, runtime_handle) = start_server(runtime).await;
+        let mut plan = stream_plan(format!("{upstream_url}/sync-json"));
+        plan.stream = false;
+
+        let response = reqwest::Client::new()
+            .post(format!("{runtime_url}/v1/execute/stream"))
+            .json(&plan)
+            .send()
+            .await
+            .expect("execution request should succeed");
+
+        assert_eq!(response.status(), StatusCode::OK);
+        let body = response.text().await.expect("frame body should read");
+        let frame_types = body
+            .lines()
+            .map(|line| {
+                serde_json::from_str::<StreamFrame>(line)
+                    .expect("execution runtime frame should decode")
+                    .frame_type
+            })
+            .collect::<Vec<_>>();
+        assert!(frame_types.contains(&StreamFrameType::Headers));
+        assert!(frame_types.contains(&StreamFrameType::Data));
+        assert!(frame_types.contains(&StreamFrameType::Eof));
+
+        runtime_handle.abort();
+        upstream_handle.abort();
+    }
+
     #[tokio::test]
     async fn execution_runtime_rejects_second_in_flight_stream_request_with_overload() {
         let upstream_hits = Arc::new(AtomicUsize::new(0));

apps/aether-gateway/src/execution_runtime/stream/execution.rs

@@ -851,6 +851,9 @@ fn merge_stream_terminal_summary(
     if current_summary.model.is_none() {
         current_summary.model = observed.model;
     }
+    if observed.provider_actual_service_tier.is_some() {
+        current_summary.provider_actual_service_tier = observed.provider_actual_service_tier;
+    }
     current_summary.observed_finish |= observed.observed_finish;
     current_summary.unknown_event_count = current_summary
         .unknown_event_count
@@ -5252,16 +5255,12 @@ async fn execute_stream_from_frame_stream(
                             telemetry.as_ref(),
                             &mut usage_stream_telemetry,
                         ) {
-                            let usage_data = state_for_report.data.as_ref().clone();
-                            state_for_report
-                                .usage_runtime
-                                .record_stream_started_direct(
-                                    &usage_data,
-                                    &lifecycle_seed_for_report,
-                                    status_code,
-                                    usage_stream_telemetry.as_ref(),
-                                )
-                                .await;
+                            state_for_report.usage_runtime.record_stream_started(
+                                state_for_report.data.as_ref(),
+                                &lifecycle_seed_for_report,
+                                status_code,
+                                usage_stream_telemetry.as_ref(),
+                            );
                         }
                         let first_data_after = usage_stream_telemetry
                             .as_ref()
@@ -5460,33 +5459,16 @@ async fn execute_stream_from_frame_stream(
                             &usage_frame_telemetry,
                         );
                         if should_refresh_stream_usage {
-                            if usage_frame_telemetry.ttfb_ms.is_some() {
-                                let usage_data = state_for_report.data.as_ref().clone();
-                                state_for_report
-                                    .usage_runtime
-                                    .record_stream_started_direct(
-                                        &usage_data,
-                                        &lifecycle_seed_for_report,
-                                        status_code,
-                                        Some(&usage_frame_telemetry),
-                                    )
-                                    .await;
-                            } else {
-                                state_for_report.usage_runtime.record_stream_started(
-                                    state_for_report.data.as_ref(),
-                                    &lifecycle_seed_for_report,
-                                    status_code,
-                                    Some(&usage_frame_telemetry),
-                                );
-                            }
+                            // The first Data frame records the live streaming transition. Later
+                            // telemetry frames only refine the terminal accumulator; persisting
+                            // every elapsed-time update would create one usage task per frame.
                             usage_stream_telemetry = Some(usage_frame_telemetry);
                         }
                         telemetry = Some(frame_telemetry);
                     }
                     StreamFramePayload::Eof { summary } => {
-                        if summary.is_some() {
-                            stream_terminal_summary = summary;
-                        }
+                        stream_terminal_summary =
+                            merge_stream_terminal_summary(stream_terminal_summary.take(), summary);
                         break;
                     }
                     StreamFramePayload::Error { error } => {
@@ -6293,12 +6275,14 @@ mod tests {
             Some(ExecutionStreamTerminalSummary {
                 standardized_usage: Some(runtime_usage),
                 model: Some("gpt-5.5".to_string()),
+                provider_actual_service_tier: Some("priority".to_string()),
                 unknown_event_count: 1,
                 ..ExecutionStreamTerminalSummary::default()
             }),
             Some(ExecutionStreamTerminalSummary {
                 standardized_usage: Some(observed_usage),
                 response_id: Some("resp_123".to_string()),
+                provider_actual_service_tier: Some("default".to_string()),
                 observed_finish: true,
                 unknown_event_count: 2,
                 ..ExecutionStreamTerminalSummary::default()
@@ -6313,6 +6297,10 @@ mod tests {
         assert_eq!(usage.output_tokens, 137);
         assert_eq!(merged.model.as_deref(), Some("gpt-5.5"));
         assert_eq!(merged.response_id.as_deref(), Some("resp_123"));
+        assert_eq!(
+            merged.provider_actual_service_tier.as_deref(),
+            Some("default")
+        );
         assert!(merged.observed_finish);
         assert_eq!(merged.unknown_event_count, 3);
     }

apps/aether-gateway/src/execution_runtime/stream_pump.rs

@@ -676,6 +676,14 @@ fn should_buffer_non_stream_response(
         return false;
     }
 
+    if report_context
+        .get("upstream_is_stream")
+        .and_then(Value::as_bool)
+        == Some(false)
+    {
+        return true;
+    }
+
     headers
         .get("content-length")
         .and_then(|value| value.trim().parse::<u64>().ok())
@@ -1134,22 +1142,36 @@ mod tests {
     }
 
     #[test]
-    fn buffers_non_sse_response_only_when_content_length_is_known() {
-        let report_context = serde_json::json!({
+    fn buffers_declared_non_stream_responses_without_relying_on_content_length() {
+        let streaming_context = serde_json::json!({
             "provider_api_format": "openai:chat",
             "client_api_format": "openai:chat",
+            "upstream_is_stream": true,
+        });
+        let non_stream_context = serde_json::json!({
+            "provider_api_format": "openai:image",
+            "client_api_format": "openai:responses",
+            "upstream_is_stream": false,
         });
 
         assert!(!should_buffer_non_stream_response(
             &BTreeMap::from([("content-type".into(), "application/json".into())]),
-            &report_context
+            &streaming_context
+        ));
+        assert!(should_buffer_non_stream_response(
+            &BTreeMap::from([("content-type".into(), "application/json".into())]),
+            &non_stream_context
         ));
         assert!(should_buffer_non_stream_response(
             &BTreeMap::from([
                 ("content-type".into(), "application/json".into()),
                 ("content-length".into(), "128".into()),
             ]),
-            &report_context
+            &streaming_context
+        ));
+        assert!(!should_buffer_non_stream_response(
+            &BTreeMap::from([("content-type".into(), "text/event-stream".into())]),
+            &non_stream_context
         ));
     }
 
@@ -1567,33 +1589,48 @@ mod tests {
             .await
             .expect("listener should bind");
         let addr = listener.local_addr().expect("local addr should resolve");
+        let generated_image = "a".repeat(32 * 1024);
+        let expected_image = generated_image.clone();
         let server = tokio::spawn(async move {
             let app = Router::new().route(
-                "/responses",
-                post(|| async {
-                    let body = serde_json::json!({
-                        "created": 1776971267_u64,
-                        "data": [{
-                            "b64_json": "aGVsbG8="
-                        }],
-                        "usage": {
-                            "total_tokens": 100,
-                            "input_tokens": 50,
-                            "output_tokens": 50,
-                            "input_tokens_details": {
-                                "text_tokens": 10,
-                                "image_tokens": 40
+                "/images/generations",
+                post(move || {
+                    let generated_image = generated_image.clone();
+                    async move {
+                        let body = serde_json::json!({
+                            "created": 1776971267_u64,
+                            "data": [{
+                                "b64_json": generated_image
+                            }],
+                            "usage": {
+                                "total_tokens": 100,
+                                "input_tokens": 50,
+                                "output_tokens": 50,
+                                "input_tokens_details": {
+                                    "text_tokens": 10,
+                                    "image_tokens": 40
+                                }
                             }
-                        }
-                    });
-                    let mut response = axum::http::Response::new(Body::from(
-                        serde_json::to_vec(&body).expect("json should encode"),
-                    ));
-                    response.headers_mut().insert(
-                        header::CONTENT_TYPE,
-                        HeaderValue::from_static("application/json"),
-                    );
-                    response
+                        });
+                        let encoded = serde_json::to_vec(&body).expect("json should encode");
+                        let chunks = encoded
+                            .chunks(4096)
+                            .map(Bytes::copy_from_slice)
+                            .collect::<Vec<_>>();
+                        let chunked_body = stream! {
+                            for chunk in chunks {
+                                yield Ok::<Bytes, Infallible>(chunk);
+                                tokio::task::yield_now().await;
+                            }
+                        };
+                        let mut response =
+                            axum::http::Response::new(Body::from_stream(chunked_body));
+                        response.headers_mut().insert(
+                            header::CONTENT_TYPE,
+                            HeaderValue::from_static("application/json"),
+                        );
+                        response
+                    }
                 }),
             );
             axum::serve(listener, app)
@@ -1611,16 +1648,15 @@ mod tests {
                 endpoint_id: "endpoint-1".to_string(),
                 key_id: "key-1".to_string(),
                 method: "POST".to_string(),
-                url: format!("http://{addr}/responses"),
+                url: format!("http://{addr}/images/generations"),
                 headers: BTreeMap::new(),
                 content_type: None,
                 content_encoding: None,
                 body: RequestBody::from_json(serde_json::json!({
                     "model": "gpt-image-1",
-                    "prompt": "poster",
-                    "stream": true
+                    "prompt": "poster"
                 })),
-                stream: true,
+                stream: false,
                 client_api_format: "openai:image".to_string(),
                 provider_api_format: "openai:image".to_string(),
                 model_name: Some("gpt-image-1".into()),
@@ -1673,7 +1709,8 @@ mod tests {
         let bridged_text = String::from_utf8(bridged_body).expect("bridged body should be utf8");
         assert!(bridged_text.contains("event: image_generation.completed"));
         assert!(bridged_text.contains("\"type\":\"image_generation.completed\""));
-        assert!(bridged_text.contains("\"b64_json\":\"aGVsbG8=\""));
+        assert!(bridged_text.contains(&format!("\"b64_json\":\"{expected_image}\"")));
+        assert!(bridged_text.len() > 32 * 1024);
         assert!(bridged_text.contains("\"total_tokens\":100"));
 
         let eof_frame = frames

apps/aether-gateway/src/execution_runtime/tests.rs

@@ -43,6 +43,7 @@ fn missing_exact_provider_request_payload(decision_kind: &str) -> AiExecutionDec
         request_id: Some("req_123".to_string()),
         candidate_id: Some("cand_123".to_string()),
         provider_name: Some("provider".to_string()),
+        provider_type: None,
         provider_id: Some("provider_id".to_string()),
         endpoint_id: Some("endpoint_id".to_string()),
         key_id: Some("key_id".to_string()),

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

@@ -57,8 +57,8 @@ const TUNNEL_RELAY_PATH_PREFIX: &str = "/api/internal/tunnel/relay";
 const DEFAULT_TUNNEL_TIMEOUT_MS: u64 = 60_000;
 const DEFAULT_STREAM_FIRST_BYTE_TIMEOUT_MS: u64 = 30_000;
 const DEFAULT_NON_STREAM_TOTAL_TIMEOUT_MS: u64 = 300_000;
+const DEFAULT_CODEX_COMPACT_TOTAL_TIMEOUT_MS: u64 = 1_200_000;
 const MIN_TUNNEL_TIMEOUT_SECS: u64 = 1;
-const MAX_TUNNEL_TIMEOUT_SECS: u64 = 300;
 const DIRECT_REQWEST_H2_CLIENT_SHARDS_ENV: &str = "AETHER_GATEWAY_DIRECT_REQWEST_H2_CLIENT_SHARDS";
 const DIRECT_REQWEST_CLIENT_SHARDS_ENV: &str = "AETHER_GATEWAY_DIRECT_REQWEST_CLIENT_SHARDS";
 const DIRECT_REQWEST_H2_TARGET_STREAMS_PER_CLIENT_ENV: &str =
@@ -512,8 +512,6 @@ pub(crate) fn format_hyper_error_chain(err: &dyn std::error::Error) -> String {
 
 #[derive(Debug, Error)]
 pub(crate) enum ExecutionRuntimeTransportError {
-    #[error("stream execution is not supported for this plan")]
-    StreamUnsupported,
     #[error("request body must contain json_body or body_bytes_b64")]
     RequestBodyRequired,
     #[error("request body base64 is invalid: {0}")]
@@ -681,10 +679,6 @@ impl DirectSyncExecutionRuntime {
         &self,
         plan: &ExecutionPlan,
     ) -> Result<DirectUpstreamStreamExecution, ExecutionRuntimeTransportError> {
-        if !plan.stream {
-            return Err(ExecutionRuntimeTransportError::StreamUnsupported);
-        }
-
         let build_body_started_at = Instant::now();
         let body_bytes = build_request_body(plan)?;
         observe_gateway_stage_ms(
@@ -835,6 +829,7 @@ fn build_stream_summary_report_context(plan: &ExecutionPlan) -> Value {
         "provider_api_format": plan.provider_api_format,
         "client_api_format": plan.client_api_format,
         "model": plan.model_name,
+        "upstream_is_stream": plan.stream,
     })
 }
 
@@ -2125,20 +2120,17 @@ pub(crate) fn build_request_body(
         Vec::new()
     };
 
-    if should_gzip_request_body(plan) && plan.body.json_body.is_some() {
-        body_bytes = gzip_bytes(&body_bytes)?;
+    if plan.body.json_body.is_some() {
+        body_bytes = match normalize_content_encoding(plan.content_encoding.as_deref()).as_deref() {
+            Some("gzip") => gzip_bytes(&body_bytes)?,
+            Some("zstd") => zstd_bytes(&body_bytes)?,
+            _ => body_bytes,
+        };
     }
 
     Ok(body_bytes)
 }
 
-fn should_gzip_request_body(plan: &ExecutionPlan) -> bool {
-    matches!(
-        normalize_content_encoding(plan.content_encoding.as_deref()).as_deref(),
-        Some("gzip")
-    )
-}
-
 fn normalize_content_encoding(value: Option<&str>) -> Option<String> {
     value
         .map(str::trim)
@@ -2156,6 +2148,11 @@ fn gzip_bytes(body_bytes: &[u8]) -> Result<Vec<u8>, ExecutionRuntimeTransportErr
         .map_err(|err| ExecutionRuntimeTransportError::RelayError(err.to_string()))
 }
 
+fn zstd_bytes(body_bytes: &[u8]) -> Result<Vec<u8>, ExecutionRuntimeTransportError> {
+    zstd::stream::encode_all(std::io::Cursor::new(body_bytes), 3)
+        .map_err(|err| ExecutionRuntimeTransportError::RelayError(err.to_string()))
+}
+
 fn build_relay_client(
     timeouts: Option<&aether_contracts::ExecutionTimeouts>,
 ) -> Result<reqwest::Client, ExecutionRuntimeTransportError> {
@@ -2218,28 +2215,49 @@ fn resolve_tunnel_first_byte_timeout(plan: &ExecutionPlan) -> Option<Duration> {
     })
 }
 
-fn resolve_non_stream_total_timeout(plan: &ExecutionPlan) -> Option<Duration> {
-    if plan.stream {
+pub(crate) fn resolve_non_stream_total_timeout_for_request(
+    is_stream: bool,
+    provider_api_format: &str,
+    timeouts: Option<&aether_contracts::ExecutionTimeouts>,
+) -> Option<Duration> {
+    if is_stream {
         return None;
     }
-    let timeout_ms = plan
-        .timeouts
-        .as_ref()
+    let default_timeout_ms =
+        if crate::ai_serving::is_openai_responses_compact_format(provider_api_format) {
+            DEFAULT_CODEX_COMPACT_TOTAL_TIMEOUT_MS
+        } else {
+            DEFAULT_NON_STREAM_TOTAL_TIMEOUT_MS
+        };
+    let timeout_ms = timeouts
         .and_then(|timeouts| timeouts.total_ms)
-        .unwrap_or(DEFAULT_NON_STREAM_TOTAL_TIMEOUT_MS);
+        .unwrap_or(default_timeout_ms);
+    Some(Duration::from_millis(timeout_ms.max(1)))
+}
+
+fn resolve_non_stream_total_timeout(plan: &ExecutionPlan) -> Option<Duration> {
+    resolve_non_stream_total_timeout_for_request(
+        plan.stream,
+        &plan.provider_api_format,
+        plan.timeouts.as_ref(),
+    )
+}
+
+pub(crate) fn resolve_stream_first_byte_timeout_for_request(
+    is_stream: bool,
+    timeouts: Option<&aether_contracts::ExecutionTimeouts>,
+) -> Option<Duration> {
+    if !is_stream {
+        return None;
+    }
+    let timeout_ms = timeouts
+        .and_then(|timeouts| timeouts.first_byte_ms)
+        .unwrap_or(DEFAULT_STREAM_FIRST_BYTE_TIMEOUT_MS);
     Some(Duration::from_millis(timeout_ms.max(1)))
 }
 
 pub(crate) fn resolve_stream_first_byte_timeout(plan: &ExecutionPlan) -> Option<Duration> {
-    if !plan.stream {
-        return None;
-    }
-    let timeout_ms = plan
-        .timeouts
-        .as_ref()
-        .and_then(|timeouts| timeouts.first_byte_ms)
-        .unwrap_or(DEFAULT_STREAM_FIRST_BYTE_TIMEOUT_MS);
-    Some(Duration::from_millis(timeout_ms.max(1)))
+    resolve_stream_first_byte_timeout_for_request(plan.stream, plan.timeouts.as_ref())
 }
 
 pub(crate) async fn with_non_stream_total_timeout<T, F>(
@@ -2359,7 +2377,10 @@ fn resolve_tunnel_timeout_metadata(plan: &ExecutionPlan) -> TunnelTimeoutMetadat
 
 fn timeout_ms_to_secs(ms: u64) -> u64 {
     let secs = ms.div_ceil(1_000);
-    secs.clamp(MIN_TUNNEL_TIMEOUT_SECS, MAX_TUNNEL_TIMEOUT_SECS)
+    secs.clamp(
+        MIN_TUNNEL_TIMEOUT_SECS,
+        aether_contracts::MAX_EXECUTION_REQUEST_TIMEOUT_SECS,
+    )
 }
 
 fn resolve_tunnel_node_id(proxy: Option<&ProxySnapshot>) -> Option<String> {
@@ -3552,7 +3573,7 @@ pub(crate) fn build_request_headers(
     let mut out = HeaderMap::new();
     let normalized_content_encoding = normalize_content_encoding(content_encoding);
     if let Some(encoding) = normalized_content_encoding.as_deref() {
-        if encoding != "gzip" && !allow_passthrough_content_encoding {
+        if !matches!(encoding, "gzip" | "zstd") && !allow_passthrough_content_encoding {
             return Err(ExecutionRuntimeTransportError::UnsupportedContentEncoding(
                 encoding.to_string(),
             ));
@@ -4637,6 +4658,25 @@ mod tests {
         assert_eq!(timeout, std::time::Duration::from_secs(300));
     }
 
+    #[test]
+    fn codex_compact_uses_the_full_unary_timeout_by_default() {
+        let mut plan = tunnel_timeout_plan(false);
+        plan.provider_api_format = "openai:responses:compact".to_string();
+        plan.timeouts = None;
+
+        let timeout = resolve_non_stream_total_timeout(&plan)
+            .expect("Codex Compact should have a total timeout");
+        let meta = build_direct_tunnel_request_meta(
+            &plan,
+            &reqwest::header::HeaderMap::new(),
+            ExecutionTransportControls::default(),
+        );
+
+        assert_eq!(timeout, std::time::Duration::from_secs(1_200));
+        assert_eq!(meta.request_timeout_ms, Some(1_200_000));
+        assert_eq!(meta.timeout, 1_200);
+    }
+
     #[test]
     fn tunnel_request_meta_uses_non_stream_default_instead_of_first_byte_default() {
         let mut plan = tunnel_timeout_plan(false);
@@ -6323,13 +6363,21 @@ mod tests {
                     .and_then(|value| value.to_str().ok())
                     .unwrap_or_default()
                     .to_string();
-                let mut decoder = flate2::read::GzDecoder::new(body.as_ref());
-                let mut decoded = String::new();
-                decoder
-                    .read_to_string(&mut decoded)
-                    .expect("gzip body should decode");
+                let decoded = match header_encoding.as_str() {
+                    "gzip" => {
+                        let mut decoder = flate2::read::GzDecoder::new(body.as_ref());
+                        let mut decoded = Vec::new();
+                        decoder
+                            .read_to_end(&mut decoded)
+                            .expect("gzip body should decode");
+                        decoded
+                    }
+                    "zstd" => zstd::stream::decode_all(std::io::Cursor::new(body.as_ref()))
+                        .expect("zstd body should decode"),
+                    encoding => panic!("unexpected content encoding: {encoding}"),
+                };
                 let decoded_json: serde_json::Value =
-                    serde_json::from_str(&decoded).expect("decoded json should parse");
+                    serde_json::from_slice(&decoded).expect("decoded json should parse");
                 (
                     axum::http::StatusCode::OK,
                     Json(json!({
@@ -6346,45 +6394,47 @@ mod tests {
         });
 
         let execution_runtime = DirectSyncExecutionRuntime::new();
-        let result = execution_runtime
-            .execute_sync(&ExecutionPlan {
-                request_id: "req-gzip-1".into(),
-                candidate_id: Some("cand-1".into()),
-                provider_name: Some("openai".into()),
-                provider_id: "prov-1".into(),
-                endpoint_id: "ep-1".into(),
-                key_id: "key-1".into(),
-                method: "POST".into(),
-                url: format!("http://{addr}/chat"),
-                headers: BTreeMap::from([("content-type".into(), "application/json".into())]),
-                content_type: Some("application/json".into()),
-                content_encoding: Some("gzip".into()),
-                body: RequestBody::from_json(json!({"model": "gpt-4.1"})),
-                stream: false,
-                client_api_format: "openai:chat".into(),
-                provider_api_format: "openai:chat".into(),
-                model_name: Some("gpt-4.1".into()),
-                proxy: None,
-                transport_profile: None,
-                timeouts: Some(ExecutionTimeouts {
-                    connect_ms: Some(5_000),
-                    total_ms: Some(LOCAL_HTTP_SUCCESS_TIMEOUT_MS),
-                    ..ExecutionTimeouts::default()
-                }),
-            })
-            .await
-            .expect("gzip sync execution should succeed");
+        for encoding in ["gzip", "zstd"] {
+            let result = execution_runtime
+                .execute_sync(&ExecutionPlan {
+                    request_id: format!("req-{encoding}-1"),
+                    candidate_id: Some("cand-1".into()),
+                    provider_name: Some("openai".into()),
+                    provider_id: "prov-1".into(),
+                    endpoint_id: "ep-1".into(),
+                    key_id: "key-1".into(),
+                    method: "POST".into(),
+                    url: format!("http://{addr}/chat"),
+                    headers: BTreeMap::from([("content-type".into(), "application/json".into())]),
+                    content_type: Some("application/json".into()),
+                    content_encoding: Some(encoding.into()),
+                    body: RequestBody::from_json(json!({"model": "gpt-4.1"})),
+                    stream: false,
+                    client_api_format: "openai:chat".into(),
+                    provider_api_format: "openai:chat".into(),
+                    model_name: Some("gpt-4.1".into()),
+                    proxy: None,
+                    transport_profile: None,
+                    timeouts: Some(ExecutionTimeouts {
+                        connect_ms: Some(5_000),
+                        total_ms: Some(LOCAL_HTTP_SUCCESS_TIMEOUT_MS),
+                        ..ExecutionTimeouts::default()
+                    }),
+                })
+                .await
+                .expect("compressed sync execution should succeed");
+
+            assert_eq!(result.status_code, 200);
+            assert_eq!(
+                result.body.and_then(|body| body.json_body),
+                Some(json!({
+                    "content_encoding": encoding,
+                    "body": {"model": "gpt-4.1"},
+                }))
+            );
+        }
 
         server.abort();
-
-        assert_eq!(result.status_code, 200);
-        assert_eq!(
-            result.body.and_then(|body| body.json_body),
-            Some(json!({
-                "content_encoding": "gzip",
-                "body": {"model": "gpt-4.1"},
-            }))
-        );
     }
 
     #[tokio::test]

apps/aether-gateway/src/executor/candidate_loop.rs

@@ -166,18 +166,31 @@ where
     type Error = GatewayError;
 
     async fn execute_attempt(&self, attempt: &T) -> Result<Option<Self::Response>, Self::Error> {
-        prewarm_direct_reqwest_candidate_client(attempt.execution_plan());
+        let plan = attempt.execution_plan();
+        let report_context = attempt.report_context();
+        if let Some(response) = execution_plan_balance_capacity_response(
+            self.state,
+            self.trace_id,
+            self.decision,
+            plan,
+            report_context.as_ref(),
+        )
+        .await?
+        {
+            return Ok(Some(response));
+        }
+        prewarm_direct_reqwest_candidate_client(plan);
         let _permit = acquire_upstream_execution_gate(self.state, self.trace_id).await?;
         let upstream_execution_gate_held_started_at = std::time::Instant::now();
         let mut response = execute_execution_runtime_sync(
             self.state,
             self.parts.uri.path(),
-            attempt.execution_plan().clone(),
+            plan.clone(),
             self.trace_id,
             self.decision,
             self.plan_kind,
             attempt.report_kind(),
-            attempt.report_context(),
+            report_context,
         )
         .await?;
         observe_gateway_stage_ms(
@@ -187,10 +200,7 @@ where
                 .as_millis() as u64,
         );
         if let Some(response) = response.as_mut() {
-            attach_redaction_execution_candidate(
-                response,
-                attempt.execution_plan().candidate_id.as_deref(),
-            );
+            attach_redaction_execution_candidate(response, plan.candidate_id.as_deref());
         }
         Ok(response)
     }
@@ -355,7 +365,14 @@ where
         };
         last_attempted = Some((attempt.execution_plan().clone(), attempt.report_context()));
         let execute_started_at = std::time::Instant::now();
-        let response = port.execute_attempt(&attempt).await?;
+        let response = match port.execute_attempt(&attempt).await {
+            Ok(response) => response,
+            Err(err) => {
+                let remaining = source.drain_execution_attempts().await?;
+                port.mark_unused_attempts(remaining).await?;
+                return Err(err);
+            }
+        };
         observe_gateway_stage_ms(
             "stream_candidate_execute",
             execute_started_at.elapsed().as_millis() as u64,
@@ -450,6 +467,17 @@ where
             candidate_index = candidate_index.as_str(),
             "candidate loop attempting stream execution candidate"
         );
+        if let Some(response) = execution_plan_balance_capacity_response(
+            self.state,
+            self.trace_id,
+            self.decision,
+            &plan,
+            report_context.as_ref(),
+        )
+        .await?
+        {
+            return Ok(Some(response));
+        }
         prewarm_direct_reqwest_candidate_client(&plan);
         let watchdog_plan = plan.clone();
         let watchdog_report_context = report_context.clone();
@@ -523,45 +551,91 @@ fn prewarm_direct_reqwest_candidate_client(plan: &aether_contracts::ExecutionPla
     );
 }
 
+async fn execution_plan_balance_capacity_response(
+    state: &AppState,
+    trace_id: &str,
+    decision: &GatewayControlDecision,
+    plan: &aether_contracts::ExecutionPlan,
+    report_context: Option<&serde_json::Value>,
+) -> Result<Option<Response<Body>>, GatewayError> {
+    let rejection = match crate::control::execution_plan_balance_capacity_rejection(
+        state,
+        decision,
+        plan,
+        report_context,
+    )
+    .await
+    {
+        Ok(rejection) => rejection,
+        Err(err) => {
+            mark_unused_local_candidate(state, plan, report_context).await;
+            return Err(err);
+        }
+    };
+    let Some(rejection) = rejection else {
+        return Ok(None);
+    };
+    mark_unused_local_candidate(state, plan, report_context).await;
+    let mut response = crate::api::response::build_local_auth_rejection_response(
+        trace_id,
+        Some(decision),
+        &rejection,
+    )?;
+    attach_redaction_execution_candidate(&mut response, plan.candidate_id.as_deref());
+    Ok(Some(response))
+}
+
 pub(crate) async fn mark_unused_local_candidates<T>(state: &AppState, remaining: Vec<T>)
 where
     T: AiExecutionAttempt,
 {
     for plan_and_report in remaining {
         let report_context = plan_and_report.report_context();
-        let metadata =
-            local_execution_candidate_metadata_from_report_context(report_context.as_ref());
-        if let Some(lease) = metadata.pool_key_lease.as_ref() {
-            if let Err(err) =
-                release_admin_provider_pool_key_lease(state.runtime_state.as_ref(), lease).await
-            {
-                warn!(
-                    error = ?err,
-                    "gateway candidate loop: failed to release unused pool key lease"
-                );
-            }
-        }
-        if should_skip_unused_persistence_from_metadata(&metadata) {
-            continue;
-        }
-        record_local_request_candidate_status(
+        mark_unused_local_candidate(
             state,
             plan_and_report.execution_plan(),
             report_context.as_ref(),
-            SchedulerRequestCandidateStatusUpdate {
-                status: RequestCandidateStatus::Unused,
-                status_code: None,
-                error_type: None,
-                error_message: None,
-                latency_ms: None,
-                started_at_unix_ms: None,
-                finished_at_unix_ms: None,
-            },
         )
         .await;
     }
 }
 
+async fn mark_unused_local_candidate(
+    state: &AppState,
+    plan: &aether_contracts::ExecutionPlan,
+    report_context: Option<&serde_json::Value>,
+) {
+    let metadata = local_execution_candidate_metadata_from_report_context(report_context);
+    if let Some(lease) = metadata.pool_key_lease.as_ref() {
+        if let Err(err) =
+            release_admin_provider_pool_key_lease(state.runtime_state.as_ref(), lease).await
+        {
+            warn!(
+                error = ?err,
+                "gateway candidate loop: failed to release unused pool key lease"
+            );
+        }
+    }
+    if should_skip_unused_persistence_from_metadata(&metadata) {
+        return;
+    }
+    record_local_request_candidate_status(
+        state,
+        plan,
+        report_context,
+        SchedulerRequestCandidateStatusUpdate {
+            status: RequestCandidateStatus::Unused,
+            status_code: None,
+            error_type: None,
+            error_message: None,
+            latency_ms: None,
+            started_at_unix_ms: None,
+            finished_at_unix_ms: None,
+        },
+    )
+    .await;
+}
+
 fn should_skip_unused_persistence(report_context: Option<&serde_json::Value>) -> bool {
     let metadata = local_execution_candidate_metadata_from_report_context(report_context);
     should_skip_unused_persistence_from_metadata(&metadata)

apps/aether-gateway/src/fallback_metrics.rs

@@ -179,6 +179,7 @@ mod tests {
             auth_context: None,
             admin_principal: None,
             local_auth_rejection: None,
+            model_directive_policy: Default::default(),
         }
     }
 

apps/aether-gateway/src/frontdoor_loop_guard.rs

@@ -41,6 +41,7 @@ pub(crate) fn frontdoor_self_loop_public_ai_path(path: &str) -> bool {
             | "/v1/rerank"
             | "/v1/responses"
             | "/v1/responses/compact"
+            | "/v1/alpha/search"
             | "/v1beta/files"
             | "/upload/v1beta/files"
             | "/v1beta/operations"

apps/aether-gateway/src/handlers/admin/observability/monitoring/cache_affinity.rs

@@ -104,6 +104,7 @@ fn is_known_admin_monitoring_api_format(value: &str) -> bool {
         "openai:chat"
             | "openai:responses"
             | "openai:responses:compact"
+            | "openai:search"
             | "openai:image"
             | "openai:video"
             | "openai:embedding"
@@ -492,6 +493,20 @@ mod tests {
         );
     }
 
+    #[test]
+    fn parses_v2_scheduler_affinity_key_for_openai_search() {
+        let parsed = parse_admin_monitoring_scheduler_affinity_key(
+            "scheduler_affinity:v2:user-key-1:openai:search:gpt-5.6-sol:codex:sessionhash",
+        )
+        .expect("Search scheduler key should parse");
+
+        assert_eq!(parsed.affinity_key, "user-key-1");
+        assert_eq!(parsed.api_format, "openai:search");
+        assert_eq!(parsed.model_name, "gpt-5.6-sol");
+        assert_eq!(parsed.client_family.as_deref(), Some("codex"));
+        assert_eq!(parsed.session_hash.as_deref(), Some("sessionhash"));
+    }
+
     #[test]
     fn parses_v2_scheduler_affinity_key_with_three_segment_api_format() {
         let parsed = parse_admin_monitoring_scheduler_affinity_key(

apps/aether-gateway/src/handlers/admin/observability/stats/analytics_routes.rs

@@ -259,6 +259,11 @@ pub(super) async fn maybe_build_local_admin_stats_analytics_response(
                     "has_format_conversion",
                 ),
                 slow_threshold_ms,
+                include_timeline: query_param_optional_bool(
+                    request_context.query_string(),
+                    "include_timeline",
+                )
+                .unwrap_or(true),
             })
             .await?;
         return Ok(Some(build_admin_stats_provider_performance_response(

apps/aether-gateway/src/handlers/admin/provider/crud/writes.rs

@@ -6,7 +6,8 @@ use crate::handlers::admin::provider::shared::payloads::{
     AdminProviderCreateRequest, AdminProviderUpdatePatch,
 };
 use crate::handlers::admin::provider::write::provider::{
-    reconcile_admin_fixed_provider_template_endpoints, reconcile_admin_fixed_provider_template_keys,
+    reconcile_admin_fixed_provider_template_endpoints,
+    reconcile_admin_fixed_provider_template_endpoints_after_update,
 };
 use crate::handlers::admin::request::{AdminAppState, AdminRequestContext};
 use crate::handlers::admin::shared::attach_admin_audit_response;
@@ -80,7 +81,6 @@ pub(crate) async fn maybe_build_local_admin_provider_writes_response(
             .is_some()
         {
             reconcile_admin_fixed_provider_template_endpoints(state, &created_provider).await?;
-            reconcile_admin_fixed_provider_template_keys(state, &created_provider).await?;
         }
         return Ok(Some(attach_admin_audit_response(
             Json(json!({
@@ -161,8 +161,12 @@ pub(crate) async fn maybe_build_local_admin_provider_writes_response(
             .fixed_provider_template(&updated_record.provider_type)
             .is_some()
         {
-            reconcile_admin_fixed_provider_template_endpoints(state, &updated_record).await?;
-            reconcile_admin_fixed_provider_template_keys(state, &updated_record).await?;
+            reconcile_admin_fixed_provider_template_endpoints_after_update(
+                state,
+                &existing_provider,
+                &updated_record,
+            )
+            .await?;
         }
         return Ok(Some(
             match state

apps/aether-gateway/src/handlers/admin/provider/oauth/quota/codex/mod.rs

@@ -51,14 +51,6 @@ fn merge_codex_quota_metadata(
     serde_json::Value::Object(merged)
 }
 
-fn codex_reset_credits_available_count(metadata: &Map<String, Value>) -> Option<u64> {
-    metadata
-        .get("reset_credits")
-        .and_then(Value::as_object)
-        .and_then(|reset_credits| reset_credits.get("available_count"))
-        .and_then(aether_admin::provider::quota::coerce_json_u64)
-}
-
 fn truncate_codex_reset_credit_detail_error(message: impl Into<String>) -> String {
     let message = message.into();
     let mut sanitized = message.replace('\n', " ");
@@ -85,11 +77,7 @@ fn merge_codex_reset_credit_detail_metadata(
         .cloned()
         .unwrap_or_default();
 
-    let has_usage_available_count = reset_credits.contains_key("available_count");
     for (key, value) in detail_reset_credits {
-        if key == "available_count" && has_usage_available_count {
-            continue;
-        }
         reset_credits.insert(key.clone(), value.clone());
     }
     codex_metadata.insert("reset_credits".to_string(), Value::Object(reset_credits));
@@ -97,6 +85,7 @@ fn merge_codex_reset_credit_detail_metadata(
 
 fn mark_codex_reset_credit_detail_failed(
     codex_metadata: &mut Map<String, Value>,
+    updated_at_unix_secs: u64,
     detail_error: impl Into<String>,
 ) {
     let mut reset_credits = codex_metadata
@@ -104,6 +93,7 @@ fn mark_codex_reset_credit_detail_failed(
         .and_then(Value::as_object)
         .cloned()
         .unwrap_or_default();
+    reset_credits.insert("updated_at".to_string(), json!(updated_at_unix_secs));
     reset_credits.insert("detail_source".to_string(), json!("wham_readonly"));
     reset_credits.insert("detail_status".to_string(), json!("failed"));
     reset_credits.insert(
@@ -124,16 +114,11 @@ async fn enrich_codex_reset_credit_details(
     codex_metadata: &mut Map<String, Value>,
     now_unix_secs: u64,
 ) -> Result<(), GatewayError> {
-    let available_count = codex_reset_credits_available_count(codex_metadata).unwrap_or(0);
-    if available_count == 0 {
-        return Ok(());
-    }
-
     let request_spec = match build_codex_reset_credits_request_spec(transport, resolved_oauth_auth)
     {
         Ok(request_spec) => request_spec,
         Err(message) => {
-            mark_codex_reset_credit_detail_failed(codex_metadata, message);
+            mark_codex_reset_credit_detail_failed(codex_metadata, now_unix_secs, message);
             return Ok(());
         }
     };
@@ -146,6 +131,7 @@ async fn enrich_codex_reset_credit_details(
             ProviderQuotaExecutionOutcome::Failure(detail) => {
                 mark_codex_reset_credit_detail_failed(
                     codex_metadata,
+                    now_unix_secs,
                     format!("reset credit detail 请求执行失败: {detail}"),
                 );
                 return Ok(());
@@ -157,6 +143,7 @@ async fn enrich_codex_reset_credit_details(
             .unwrap_or_else(|| format!("HTTP {}", result.status_code));
         mark_codex_reset_credit_detail_failed(
             codex_metadata,
+            now_unix_secs,
             format!(
                 "reset credit detail 返回状态码 {}: {detail}",
                 result.status_code
@@ -170,7 +157,11 @@ async fn enrich_codex_reset_credit_details(
         .as_ref()
         .and_then(|body| body.json_body.as_ref())
     else {
-        mark_codex_reset_credit_detail_failed(codex_metadata, "无法解析 reset credit detail 响应");
+        mark_codex_reset_credit_detail_failed(
+            codex_metadata,
+            now_unix_secs,
+            "无法解析 reset credit detail 响应",
+        );
         return Ok(());
     };
     if let Some(detail_metadata) =
@@ -178,7 +169,11 @@ async fn enrich_codex_reset_credit_details(
     {
         merge_codex_reset_credit_detail_metadata(codex_metadata, &detail_metadata);
     } else {
-        mark_codex_reset_credit_detail_failed(codex_metadata, "reset credit detail 响应为空");
+        mark_codex_reset_credit_detail_failed(
+            codex_metadata,
+            now_unix_secs,
+            "reset credit detail 响应为空",
+        );
     }
 
     Ok(())
@@ -776,3 +771,52 @@ pub(crate) async fn refresh_codex_provider_quota_locally(
         "auto_removed_hard_banned": auto_removed_hard_banned_count,
     })))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn codex_reset_credit_detail_count_overrides_usage_count() {
+        let mut metadata = json!({
+            "reset_credits": {
+                "available_count": 0,
+                "detail_source": "wham_usage"
+            }
+        })
+        .as_object()
+        .cloned()
+        .expect("metadata object");
+        let detail = json!({
+            "reset_credits": {
+                "available_count": 2,
+                "detail_source": "wham_readonly"
+            }
+        });
+
+        merge_codex_reset_credit_detail_metadata(&mut metadata, &detail);
+
+        assert_eq!(
+            metadata
+                .get("reset_credits")
+                .and_then(Value::as_object)
+                .and_then(|credits| credits.get("available_count")),
+            Some(&json!(2u64))
+        );
+    }
+
+    #[test]
+    fn codex_reset_credit_detail_failure_records_attempt_time() {
+        let mut metadata = Map::new();
+
+        mark_codex_reset_credit_detail_failed(&mut metadata, 1_777_000_000, "request failed");
+
+        assert_eq!(
+            metadata
+                .get("reset_credits")
+                .and_then(Value::as_object)
+                .and_then(|credits| credits.get("updated_at")),
+            Some(&json!(1_777_000_000u64))
+        );
+    }
+}

apps/aether-gateway/src/handlers/admin/provider/pool/runtime/writes.rs

@@ -600,7 +600,7 @@ mod tests {
     };
     use crate::AppState;
     use aether_runtime_state::{RedisClientConfig, RuntimeState, RuntimeStateConfig};
-    use aether_testkit::ManagedRedisServer;
+    use aether_test_support::ManagedRedisServer;
     use std::collections::BTreeMap;
 
     async fn start_managed_redis_or_skip() -> Option<ManagedRedisServer> {

apps/aether-gateway/src/handlers/admin/provider/pool_admin/batch_routes/import.rs

@@ -55,13 +55,6 @@ pub(super) async fn build_admin_pool_batch_import_response(
         }
     };
 
-    if payload.keys.len() > 500 {
-        return Ok(build_admin_pool_error_response(
-            http::StatusCode::BAD_REQUEST,
-            "keys length must be less than or equal to 500",
-        ));
-    }
-
     state
         .build_admin_pool_batch_import_response(&provider_id, payload)
         .await

apps/aether-gateway/src/handlers/admin/provider/query/models/mod.rs

@@ -64,7 +64,8 @@ use aether_data_contracts::repository::provider_catalog::{
 };
 use aether_model_fetch::{
     aggregate_models_for_cache, fetch_models_from_transports, json_string_list,
-    merge_upstream_metadata, preset_models_for_provider, selected_models_fetch_endpoints,
+    model_catalog_upstream_metadata, preset_models_for_provider, selected_models_fetch_endpoints,
+    upstream_metadata_namespace_updates,
 };
 use axum::{
     body::{to_bytes, Body},
@@ -301,6 +302,7 @@ fn provider_query_attach_model_test_capabilities(
 
 fn provider_query_codex_preset_fallback(
     provider: &StoredProviderCatalogProvider,
+    fetch_error: &str,
 ) -> Option<ProviderQueryKeyFetchResult> {
     if !provider.provider_type.trim().eq_ignore_ascii_case("codex") {
         return None;
@@ -309,12 +311,59 @@ fn provider_query_codex_preset_fallback(
     Some(ProviderQueryKeyFetchResult {
         models: aggregate_models_for_cache(&models),
         error: None,
-        warning: None,
+        warning: Some(format!(
+            "Codex 动态模型目录不可用，已使用内置模型卡：{fetch_error}"
+        )),
         from_cache: false,
         has_success: true,
     })
 }
 
+async fn provider_query_persist_preset_models(
+    state: &AdminAppState<'_>,
+    provider: &StoredProviderCatalogProvider,
+    key: &StoredProviderCatalogKey,
+    models: &[Value],
+) -> Result<(), GatewayError> {
+    if models.is_empty() {
+        return Ok(());
+    }
+    <AppState as ModelFetchRuntimeState>::write_upstream_models_cache(
+        state.app(),
+        &provider.id,
+        &key.id,
+        models,
+    )
+    .await;
+    if let Some(catalog_metadata) = model_catalog_upstream_metadata(&provider.provider_type, models)
+    {
+        provider_query_persist_upstream_metadata(state, key, &catalog_metadata).await?;
+    }
+    Ok(())
+}
+
+async fn provider_query_persist_upstream_metadata(
+    state: &AdminAppState<'_>,
+    key: &StoredProviderCatalogKey,
+    upstream_metadata: &Value,
+) -> Result<(), GatewayError> {
+    let updated_at = current_unix_secs();
+    for (namespace, value) in
+        upstream_metadata_namespace_updates(key.upstream_metadata.as_ref(), upstream_metadata)
+    {
+        state
+            .app()
+            .upsert_provider_catalog_key_upstream_metadata_namespace(
+                &key.id,
+                &namespace,
+                &value,
+                Some(updated_at),
+            )
+            .await?;
+    }
+    Ok(())
+}
+
 mod model_test;
 
 pub(crate) use self::model_test::{
@@ -459,11 +508,9 @@ async fn provider_query_fetch_models_for_key(
     let selected_endpoints = selected_models_fetch_endpoints(endpoints, key);
     if selected_endpoints.is_empty() {
         if let Some(models) = preset_models_for_provider(&provider.provider_type) {
-            let models = provider_query_filter_models_for_key(
-                provider,
-                key,
-                aggregate_models_for_cache(&models),
-            );
+            let models = aggregate_models_for_cache(&models);
+            provider_query_persist_preset_models(state, provider, key, &models).await?;
+            let models = provider_query_filter_models_for_key(provider, key, models);
             return Ok(ProviderQueryKeyFetchResult {
                 models,
                 error: None,
@@ -512,7 +559,11 @@ async fn provider_query_fetch_models_for_key(
         Ok(outcome) => outcome,
         Err(err) => {
             all_errors.push(err);
-            if let Some(fallback) = provider_query_codex_preset_fallback(provider) {
+            if let Some(fallback) =
+                provider_query_codex_preset_fallback(provider, &all_errors.join("; "))
+            {
+                provider_query_persist_preset_models(state, provider, key, &fallback.models)
+                    .await?;
                 return Ok(fallback);
             }
             return Ok(ProviderQueryKeyFetchResult {
@@ -537,20 +588,14 @@ async fn provider_query_fetch_models_for_key(
         .await;
     }
     if let Some(upstream_metadata) = outcome.upstream_metadata.as_ref() {
-        let merged_metadata =
-            merge_upstream_metadata(key.upstream_metadata.as_ref(), upstream_metadata);
-        state
-            .app()
-            .update_provider_catalog_key_upstream_metadata(
-                &key.id,
-                Some(&merged_metadata),
-                Some(current_unix_secs()),
-            )
-            .await?;
+        provider_query_persist_upstream_metadata(state, key, upstream_metadata).await?;
     }
 
     if unique_models.is_empty() && !all_errors.is_empty() {
-        if let Some(fallback) = provider_query_codex_preset_fallback(provider) {
+        if let Some(fallback) =
+            provider_query_codex_preset_fallback(provider, &all_errors.join("; "))
+        {
+            provider_query_persist_preset_models(state, provider, key, &fallback.models).await?;
             return Ok(fallback);
         }
     }