feat(openai): align GPT-5.6 and Codex request contracts

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");
 }
 
@@ -1841,6 +1842,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 +1910,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

@@ -48,16 +48,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,6 +702,7 @@ 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,
@@ -730,6 +731,7 @@ 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,
         require_streaming,
@@ -1151,6 +1153,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 +1954,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,8 +2183,11 @@ 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",
             true,
@@ -2233,6 +2242,7 @@ mod tests {
 
         let mut page_cursor = LocalCandidatePreselectionPageCursor::new(
             PlannerAppState::new(&app),
+            &model_directive_policy,
             "openai:chat",
             "gpt-5",
             true,
@@ -2269,6 +2279,7 @@ mod tests {
             );
         let mut page_cursor = LocalCandidatePreselectionPageCursor::new(
             PlannerAppState::new(&fixed_order_app),
+            &model_directive_policy,
             "openai:chat",
             "gpt-5",
             true,

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

@@ -64,10 +64,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;
@@ -99,12 +114,13 @@ impl AiCandidatePreselectionPort for GatewayLocalCandidatePreselectionPort<'_> {
             .state
             .list_selectable_candidates_with_skip_reasons(
                 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,
             )
             .await?;
 
@@ -123,16 +139,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 +155,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,9 +174,27 @@ 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,
     require_streaming: bool,
@@ -190,6 +218,7 @@ 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,
         require_streaming,
@@ -207,6 +236,7 @@ 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,
     require_streaming: bool,
@@ -224,19 +254,11 @@ 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,
@@ -249,7 +271,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(),
     };
 
@@ -271,7 +293,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,9 +317,23 @@ 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,
         require_streaming: bool,
@@ -315,19 +352,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(
@@ -351,7 +380,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,
@@ -426,6 +456,10 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
         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
@@ -491,6 +525,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 +787,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 +804,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 +831,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 +852,6 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
                         .next_fallback_page_for_api_format(
                             candidate_api_format,
                             &normalized_api_format,
-                            enable_model_directives,
                         )
                         .await;
                 }
@@ -835,7 +862,6 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
                 .build_page_outcome_from_rows(
                     candidate_api_format,
                     &normalized_api_format,
-                    enable_model_directives,
                     page.rows,
                 )
                 .await?
@@ -849,17 +875,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 +899,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 +939,6 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
         &mut self,
         candidate_api_format: &str,
         normalized_api_format: &str,
-        enable_model_directives: bool,
     ) -> Result<
         Option<
             AiCandidatePreselectionOutcome<
@@ -930,6 +955,7 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
             return Ok(None);
         }
 
+        let routing_model = self.routing_model(candidate_api_format).to_string();
         let rows = self
             .state
             .app()
@@ -941,27 +967,21 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
             .filter(|row| {
                 row_supports_requested_model_with_model_directives(
                     row,
-                    &self.requested_model,
+                    &routing_model,
                     normalized_api_format,
-                    enable_model_directives,
+                    false,
                 )
             })
             .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,15 +1004,16 @@ 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,
+                    &routing_model,
                     normalized_api_format,
-                    enable_model_directives,
+                    false,
                 ) else {
                     return Ok(None);
                 };
@@ -1016,22 +1037,18 @@ impl<'a> LocalCandidatePreselectionPageCursor<'a> {
             EnumerateMinimalCandidateSelectionInput {
                 rows,
                 normalized_api_format,
-                requested_model_name: &self.requested_model,
+                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 +1082,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 +1096,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 +1105,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 +1114,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 +1123,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 +1210,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 +1228,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,8 +1309,11 @@ 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",
             true,
@@ -1545,8 +1554,11 @@ 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",
             false,
@@ -1578,6 +1590,77 @@ mod tests {
         );
     }
 
+    #[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",
+            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,8 +1688,11 @@ 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",
             false,
@@ -1680,8 +1766,11 @@ 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",
             false,

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,
@@ -54,10 +55,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 +179,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_input.rs

@@ -14,7 +14,10 @@ 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::ai_serving::{
+    ExecutionRuntimeAuthContext, GatewayAuthApiKeySnapshot, GatewayProviderTransportSnapshot,
+    PlannerAppState,
+};
 use crate::client_session_affinity::client_session_affinity_from_request;
 use crate::clock::current_unix_secs;
 use crate::routing::{
@@ -27,12 +30,16 @@ 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";
+const CODEX_RESPONSES_LITE_HEADER: &str = "x-openai-internal-codex-responses-lite";
 
 #[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 +53,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 +94,52 @@ 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_with_capabilities(
+        &mut decision.provider_request_headers,
+        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,80 @@ 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_with_capabilities(
+        &mut provider_request_headers,
+        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 +280,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 +318,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 +333,7 @@ impl AiAuthenticatedDecisionInputPort for GatewayAuthenticatedDecisionInputPort<
             auth_context,
             auth_snapshot,
             required_capabilities,
+            model_directive_policy: self.model_directive_policy.clone(),
         }
     }
 }
@@ -213,6 +352,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,
     }
 }
 
@@ -373,12 +513,16 @@ 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;
     }
@@ -475,11 +619,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 +885,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 +941,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 +990,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 +1030,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_summaries": 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 +1136,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 +1204,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 +1240,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 +1269,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 +1449,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 +1474,7 @@ mod tests {
         let mut input = sample_decision_input();
         set_provider_request_rules(
             &mut input,
+            &["gpt-5"],
             json!([{
                 "type": "patch_headers",
                 "patch": [{
@@ -1080,7 +1488,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 +1520,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

@@ -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
     {
@@ -115,15 +117,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 +221,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,
@@ -137,13 +139,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 +184,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 +211,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 +238,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 +517,27 @@ 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_with_capabilities(
+        &mut provider_request_headers,
+        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,29 @@
 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> {
+    if !transport
+        .provider
+        .provider_type
+        .trim()
+        .eq_ignore_ascii_case("codex")
+        || !crate::ai_serving::is_openai_responses_family_format(provider_api_format)
+    {
+        return None;
+    }
+    Some(
+        crate::ai_serving::resolve_codex_responses_model_capabilities(
+            provider_model,
+            source_model,
+            transport.key.upstream_metadata.as_ref(),
+        ),
+    )
+}

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

@@ -1,8 +1,6 @@
 use std::collections::BTreeMap;
 
-use super::{
-    apply_codex_openai_responses_special_body_edits, apply_codex_openai_responses_special_headers,
-};
+use super::{apply_codex_openai_responses_special_body_edits, apply_codex_openai_special_headers};
 use crate::ai_serving::planner::standard::build_local_openai_responses_request_body;
 use http::{HeaderMap, HeaderValue};
 use serde_json::json;
@@ -10,7 +8,7 @@ use serde_json::json;
 #[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 +29,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 +79,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 +98,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 +134,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 +157,91 @@ 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_auth_identity_headers() {
     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(),
+    );
     let body = json!({
         "model": "gpt-5",
         "prompt_cache_key": "172c39e6-c0a0-5a70-8b63-e0f8e0d185a3",
@@ -205,12 +252,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,15 +267,21 @@ 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!(
@@ -237,47 +290,52 @@ fn respects_existing_codex_request_and_session_headers() {
     );
     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!(!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,6 +121,7 @@ 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,
         false,
@@ -243,6 +246,7 @@ 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,
@@ -338,6 +342,7 @@ 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,
         spec_metadata.require_streaming,

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", "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,6 +293,7 @@ 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,

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

@@ -21,6 +21,7 @@ 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,
         require_streaming,

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.get("accept").is_none());
+    }
+
     #[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,13 @@ 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_with_capabilities(
             &mut provider_request_headers,
-            transport.key.decrypted_auth_config.as_deref(),
+            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 +856,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 +869,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 +1009,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 +1022,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 +1250,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 +1270,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 +1291,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 +1323,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 +1355,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 +1368,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 +1399,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 +1472,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 +1674,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 +1885,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 +1908,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

@@ -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
     {
@@ -171,6 +173,7 @@ 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,
         spec_metadata.require_streaming,
@@ -280,6 +283,7 @@ 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,
@@ -365,6 +369,7 @@ 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,
         false,

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,7 @@ impl<'a> PlannerAppState<'a> {
         auth_snapshot: Option<&GatewayAuthApiKeySnapshot>,
         client_session_affinity: Option<&ClientSessionAffinity>,
         now_unix_secs: u64,
+        enable_model_directives: bool,
     ) -> Result<
         (
             Vec<SchedulerMinimalCandidateSelectionCandidate>,
@@ -63,14 +58,6 @@ 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(
                 self.app().data.as_ref(),

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

@@ -3,10 +3,14 @@ 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_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 +45,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 +68,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,14 +142,15 @@ 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,