fix(codex): trigger image override only on explicit tool_choice

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

@@ -9,7 +9,6 @@ pub(super) use self::payload::maybe_build_local_openai_chat_decision_payload_for
 pub(super) use self::support::{
     build_lazy_local_openai_chat_candidate_attempt_source,
     build_local_openai_chat_candidate_attempt_source,
-    build_local_openai_chat_image_candidate_attempt_source,
     materialize_local_openai_chat_candidate_attempts, LocalOpenAiChatCandidateAttempt,
     LocalOpenAiChatCandidateAttemptSource, LocalOpenAiChatDecisionInput,
 };

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

@@ -4,7 +4,7 @@ use std::sync::Arc;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use aether_contracts::ResolvedTransportProfile;
-use serde_json::{json, Value};
+use serde_json::Value;
 
 use crate::ai_serving::planner::candidate_preparation::{
     prepare_header_authenticated_candidate, prepare_header_authenticated_candidate_from_auth,
@@ -16,10 +16,9 @@ use crate::ai_serving::planner::common::{
     request_requires_body_stream_field, OPENAI_CHAT_STREAM_PLAN_KIND,
 };
 use crate::ai_serving::planner::standard::{
-    apply_codex_openai_responses_special_body_edits, apply_codex_openai_responses_special_headers,
+    apply_codex_openai_responses_special_headers, build_cross_format_openai_chat_request_body,
-    build_cross_format_openai_chat_request_body, build_cross_format_openai_chat_upstream_url,
+    build_cross_format_openai_chat_upstream_url, build_local_openai_chat_request_body,
-    build_local_openai_chat_request_body, build_local_openai_chat_upstream_url,
+    build_local_openai_chat_upstream_url, request_body_build_failure_extra_data,
-    request_body_build_failure_extra_data,
 };
 use crate::ai_serving::transport::auth::resolve_local_openai_bearer_auth;
 use crate::ai_serving::transport::kiro::{
@@ -30,8 +29,8 @@ use crate::ai_serving::transport::kiro::{
 use crate::ai_serving::transport::local_openai_chat_transport_unsupported_reason;
 use crate::ai_serving::transport::{
     build_grok_browser_headers, build_grok_upstream_url, build_kiro_cross_format_upstream_url,
-    build_standard_provider_request_headers, GrokHeaderInput,
+    build_standard_provider_request_headers, GrokHeaderInput, StandardProviderRequestHeadersInput,
-    StandardProviderRequestHeadersInput, GROK_CHAT_PATH,
+    GROK_CHAT_PATH,
 };
 use crate::ai_serving::{
     ai_local_execution_contract_for_formats, request_conversion_direct_auth,
@@ -790,450 +789,6 @@ pub(crate) async fn resolve_local_openai_chat_candidate_payload_parts(
     }))
 }
 
-#[allow(dead_code)]
-#[allow(clippy::too_many_arguments)]
-async fn resolve_openai_chat_to_openai_image_payload_parts(
-    state: &AppState,
-    parts: &http::request::Parts,
-    trace_id: &str,
-    body_json: &serde_json::Value,
-    input: &LocalOpenAiChatDecisionInput,
-    eligible: &EligibleLocalExecutionCandidate,
-    candidate_index: u32,
-    candidate_id: &str,
-    upstream_is_stream: bool,
-) -> Result<Option<LocalOpenAiChatCandidatePayloadParts>, GatewayError> {
-    let candidate = &eligible.candidate;
-    let transport = &eligible.transport;
-    let provider_api_format = "openai:image";
-    if let Some(skip_reason) =
-        openai_image_transport_unsupported_reason(transport, provider_api_format)
-    {
-        mark_skipped_local_openai_chat_candidate(
-            state,
-            input,
-            trace_id,
-            candidate,
-            candidate_index,
-            candidate_id,
-            skip_reason,
-        )
-        .await;
-        return Ok(None);
-    }
-
-    let prepared_candidate = match prepare_header_authenticated_candidate(
-        crate::ai_serving::PlannerAppState::new(state),
-        transport,
-        candidate,
-        resolve_openai_image_auth(transport),
-        OauthPreparationContext {
-            trace_id,
-            api_format: provider_api_format,
-            operation: "openai_chat_image_bridge",
-        },
-    )
-    .await
-    {
-        Ok(prepared) => prepared,
-        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 is_chatgpt_web = transport
-        .provider
-        .provider_type
-        .trim()
-        .eq_ignore_ascii_case("chatgpt_web");
-    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,
-            &input.requested_model,
-        )
-    } else {
-        build_openai_image_provider_body_from_openai_chat_body(
-            body_json,
-            &input.requested_model,
-            upstream_is_stream,
-        )
-    }) 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);
-    };
-    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 upstream_url = if is_chatgpt_web {
-        chatgpt_web_image_internal_url(&transport.endpoint.base_url)
-    } else {
-        build_openai_image_upstream_url(transport, parts.uri.query())
-    };
-    let Some(mut provider_request_headers) =
-        build_openai_image_headers(ProviderOpenAiImageHeadersInput {
-            headers: &parts.headers,
-            auth_header: &prepared_candidate.auth_header,
-            auth_value: &prepared_candidate.auth_value,
-            header_rules: transport.endpoint.header_rules.as_ref(),
-            provider_request_body: &provider_request_body,
-            original_request_body: body_json,
-        })
-    else {
-        mark_skipped_local_openai_chat_candidate_with_failure_diagnostic(
-            state,
-            input,
-            trace_id,
-            candidate,
-            candidate_index,
-            candidate_id,
-            "transport_header_rules_apply_failed",
-            CandidateFailureDiagnostic::header_rules_apply_failed(
-                "openai:chat",
-                provider_api_format,
-                "openai_chat_image_bridge_headers",
-            ),
-        )
-        .await;
-        return Ok(None);
-    };
-    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(
-            &mut provider_request_headers,
-            &provider_request_body,
-            &parts.headers,
-            transport.provider.provider_type.as_str(),
-            provider_api_format,
-            Some(trace_id),
-            transport.key.decrypted_auth_config.as_deref(),
-        );
-    }
-
-    let (execution_strategy, conversion_mode) =
-        ai_local_execution_contract_for_formats("openai:chat", provider_api_format);
-
-    Ok(Some(LocalOpenAiChatCandidatePayloadParts {
-        client_api_format: "openai:chat".to_string(),
-        auth_header: prepared_candidate.auth_header,
-        auth_value: prepared_candidate.auth_value,
-        mapped_model: prepared_candidate.mapped_model,
-        provider_api_format: provider_api_format.to_string(),
-        provider_request_body,
-        provider_request_headers,
-        upstream_url,
-        execution_strategy,
-        conversion_mode,
-        report_kind: "openai_chat_stream_success".to_string(),
-        envelope_name: None,
-        transport: Arc::clone(transport),
-        request_redacted: false,
-        transport_profile: None,
-        image_request_summary: Some(image_request_summary),
-    }))
-}
-
-#[allow(dead_code)]
-fn build_openai_image_provider_body_from_openai_chat_body(
-    body_json: &Value,
-    requested_model: &str,
-    upstream_is_stream: bool,
-) -> Option<(Value, Value)> {
-    let (prompt, images) = collect_openai_chat_image_prompt_and_images(body_json)?;
-    let operation = if images.is_empty() {
-        "generate"
-    } else {
-        "edit"
-    };
-    let mut image_options = serde_json::Map::new();
-    copy_openai_chat_image_option(body_json, &mut image_options, "size");
-    copy_openai_chat_image_option(body_json, &mut image_options, "quality");
-    copy_openai_chat_image_option(body_json, &mut image_options, "background");
-    copy_openai_chat_image_option(body_json, &mut image_options, "output_format");
-    copy_openai_chat_image_option(body_json, &mut image_options, "output_compression");
-    copy_openai_chat_image_option(body_json, &mut image_options, "moderation");
-    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()));
-    }
-    body.insert("input".to_string(), input);
-    if upstream_is_stream {
-        body.insert("stream".to_string(), Value::Bool(true));
-    }
-    if let Some(user) = body_json
-        .get("user")
-        .and_then(Value::as_str)
-        .map(str::trim)
-        .filter(|value| !value.is_empty())
-    {
-        body.insert("user".to_string(), Value::String(user.to_string()));
-    }
-
-    let mut summary = serde_json::Map::new();
-    summary.insert(
-        "operation".to_string(),
-        Value::String(operation.to_string()),
-    );
-    for key in ["output_format", "partial_images", "size", "quality"] {
-        if let Some(value) = image_options.get(key) {
-            summary.insert(key.to_string(), value.clone());
-        }
-    }
-    Some((Value::Object(body), Value::Object(summary)))
-}
-
-#[allow(dead_code)]
-fn build_chatgpt_web_image_provider_body_from_openai_chat_body(
-    body_json: &Value,
-    requested_model: &str,
-) -> Option<(Value, Value)> {
-    let (prompt, images) = collect_openai_chat_image_prompt_and_images(body_json)?;
-    let operation = if images.is_empty() {
-        "generate"
-    } else {
-        "edit"
-    };
-    let size = body_json
-        .get("size")
-        .and_then(Value::as_str)
-        .map(str::trim)
-        .filter(|value| !value.is_empty())
-        .unwrap_or("1024x1024");
-    let output_format = body_json
-        .get("output_format")
-        .and_then(Value::as_str)
-        .map(str::trim)
-        .filter(|value| !value.is_empty())
-        .unwrap_or("png");
-    let quality = body_json
-        .get("quality")
-        .and_then(Value::as_str)
-        .map(str::trim)
-        .filter(|value| !value.is_empty())
-        .unwrap_or("medium");
-    let model = body_json
-        .get("model")
-        .and_then(Value::as_str)
-        .map(str::trim)
-        .filter(|value| !value.is_empty())
-        .unwrap_or_else(|| requested_model.trim());
-    let web_model = body_json
-        .get("web_model")
-        .and_then(Value::as_str)
-        .map(str::trim)
-        .filter(|value| !value.is_empty())
-        .unwrap_or("gpt-5-5-thinking");
-    let image_urls = openai_image_inputs_as_urls(&images);
-
-    let body = json!({
-        "operation": operation,
-        "model": if model.is_empty() { "gpt-image-2" } else { model },
-        "web_model": web_model,
-        "prompt": prompt,
-        "size": size,
-        "ratio": chatgpt_web_ratio_for_size(size),
-        "output_format": output_format,
-        "images": image_urls,
-    });
-    let summary = json!({
-        "operation": operation,
-        "output_format": output_format,
-        "size": size,
-        "quality": quality,
-    });
-    Some((body, summary))
-}
-
-#[allow(dead_code)]
-fn copy_openai_chat_image_option(
-    body_json: &Value,
-    image_options: &mut serde_json::Map<String, Value>,
-    key: &str,
-) {
-    if let Some(value) = body_json.get(key) {
-        image_options.insert(key.to_string(), value.clone());
-    }
-}
-
-#[allow(dead_code)]
-fn collect_openai_chat_image_prompt_and_images(body_json: &Value) -> Option<(String, Vec<Value>)> {
-    let messages = body_json.get("messages").and_then(Value::as_array)?;
-    let mut prompt_parts = Vec::new();
-    let mut images = Vec::new();
-    for message in messages.iter().filter_map(Value::as_object) {
-        let role = message
-            .get("role")
-            .and_then(Value::as_str)
-            .map(str::trim)
-            .unwrap_or_default();
-        let content = message.get("content");
-        if matches!(role, "system" | "developer" | "user") {
-            if let Some(text) = crate::ai_serving::extract_openai_text_content(content)
-                .map(|value| value.trim().to_string())
-                .filter(|value| !value.is_empty())
-            {
-                prompt_parts.push(text);
-            }
-        }
-        if role == "user" {
-            collect_openai_chat_image_inputs(content, &mut images);
-        }
-    }
-    let prompt = prompt_parts.join("\n").trim().to_string();
-    (!prompt.is_empty()).then_some((prompt, images))
-}
-
-#[allow(dead_code)]
-fn collect_openai_chat_image_inputs(content: Option<&Value>, images: &mut Vec<Value>) {
-    let Some(parts) = content.and_then(Value::as_array) else {
-        return;
-    };
-    for part in parts.iter().filter_map(Value::as_object) {
-        let part_type = part
-            .get("type")
-            .and_then(Value::as_str)
-            .map(str::trim)
-            .unwrap_or_default();
-        if matches!(part_type, "image_url" | "input_image") {
-            if let Some(url) = part
-                .get("image_url")
-                .and_then(|value| {
-                    value
-                        .as_str()
-                        .or_else(|| value.get("url").and_then(Value::as_str))
-                })
-                .map(str::trim)
-                .filter(|value| !value.is_empty())
-            {
-                images.push(serde_json::json!({
-                    "type": "input_image",
-                    "image_url": url,
-                }));
-            } else if let Some(file_id) = part
-                .get("file_id")
-                .and_then(Value::as_str)
-                .map(str::trim)
-                .filter(|value| !value.is_empty())
-            {
-                images.push(serde_json::json!({
-                    "type": "input_image",
-                    "file_id": file_id,
-                }));
-            }
-        }
-    }
-}
-
-#[allow(dead_code)]
-fn openai_image_inputs_as_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| Value::String(value.to_string()))
-        })
-        .collect()
-}
-
-#[allow(dead_code)]
-fn chatgpt_web_ratio_for_size(size: &str) -> String {
-    let Some((width, height)) = size.split_once('x') else {
-        return "1:1".to_string();
-    };
-    let Ok(width) = width.trim().parse::<u64>() else {
-        return "1:1".to_string();
-    };
-    let Ok(height) = height.trim().parse::<u64>() else {
-        return "1:1".to_string();
-    };
-    if width == 0 || height == 0 {
-        return "1:1".to_string();
-    }
-    let divisor = gcd(width, height);
-    format!("{}:{}", width / divisor, height / divisor)
-}
-
-#[allow(dead_code)]
-fn gcd(mut left: u64, mut right: u64) -> u64 {
-    while right != 0 {
-        let next = left % right;
-        left = right;
-        right = next;
-    }
-    left.max(1)
-}
-
-#[allow(dead_code)]
-fn chatgpt_web_image_internal_url(base_url: &str) -> String {
-    let base_url = base_url.trim().trim_end_matches('/');
-    let base_url = if base_url.is_empty() {
-        "https://chatgpt.com"
-    } else {
-        base_url
-    };
-    format!("{base_url}/__aether/chatgpt-web-image")
-}
-
 #[allow(clippy::too_many_arguments)]
 async fn build_kiro_openai_chat_cross_format_payload_parts(
     state: &AppState,
@@ -1457,69 +1012,3 @@ fn redaction_mask_error_to_gateway_error(error: RedactionMaskError) -> GatewayEr
         },
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn chatgpt_web_chat_image_bridge_body_uses_internal_web_shape() {
-        let body_json = json!({
-            "model": "gpt-image-2",
-            "messages": [
-                {"role": "system", "content": "Use crisp vector-like shapes."},
-                {
-                    "role": "user",
-                    "content": [
-                        {"type": "text", "text": "Draw a glass city"},
-                        {"type": "image_url", "image_url": {"url": "https://example.com/ref.png"}}
-                    ]
-                }
-            ],
-            "size": "1536x1024",
-            "output_format": "webp",
-            "web_model": "gpt-5-image-test"
-        });
-
-        let (provider_body, summary) =
-            build_chatgpt_web_image_provider_body_from_openai_chat_body(&body_json, "gpt-image-2")
-                .expect("chat image body should convert");
-
-        assert_eq!(provider_body["operation"], "edit");
-        assert_eq!(provider_body["model"], "gpt-image-2");
-        assert_eq!(provider_body["web_model"], "gpt-5-image-test");
-        assert_eq!(
-            provider_body["prompt"],
-            "Use crisp vector-like shapes.\nDraw a glass city"
-        );
-        assert_eq!(provider_body["size"], "1536x1024");
-        assert_eq!(provider_body["ratio"], "3:2");
-        assert_eq!(provider_body["output_format"], "webp");
-        assert_eq!(provider_body["images"][0], "https://example.com/ref.png");
-        assert_eq!(summary["operation"], "edit");
-        assert_eq!(summary["output_format"], "webp");
-    }
-
-    #[test]
-    fn openai_chat_image_bridge_body_does_not_inject_tools() {
-        let body_json = json!({
-            "model": "gpt-image-2",
-            "messages": [
-                {"role": "user", "content": "Draw a glass city"}
-            ],
-            "size": "1024x1024",
-            "output_format": "png"
-        });
-
-        let (provider_body, summary) =
-            build_openai_image_provider_body_from_openai_chat_body(&body_json, "gpt-image-2", true)
-                .expect("chat image body should convert");
-
-        assert!(provider_body.get("tools").is_none());
-        assert_eq!(provider_body["model"], "gpt-image-2");
-        assert_eq!(provider_body["stream"], true);
-        assert_eq!(provider_body["input"][0]["content"], "Draw a glass city");
-        assert_eq!(summary["operation"], "generate");
-        assert_eq!(summary["output_format"], "png");
-    }
-}

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

@@ -14,10 +14,7 @@ use crate::ai_serving::planner::candidate_metadata::{
     LocalExecutionCandidateMetadataParts,
 };
 use crate::ai_serving::planner::candidate_resolution::SkippedLocalExecutionCandidate;
-use crate::ai_serving::planner::candidate_source::{
+use crate::ai_serving::planner::candidate_source::LocalCandidatePreselectionKeyMode;
-    preselect_local_execution_candidates_for_api_formats_with_serving,
-    LocalCandidatePreselectionKeyMode,
-};
 use crate::ai_serving::planner::materialization_policy::{
     build_local_candidate_persistence_policy, LocalCandidatePersistencePolicyKind,
 };
@@ -26,7 +23,7 @@ use crate::ai_serving::{
     ai_local_execution_contract_for_formats, extract_pool_sticky_session_token,
     ExecutionRuntimeAuthContext, PlannerAppState,
 };
-use crate::{AppState, GatewayError};
+use crate::AppState;
 
 pub(crate) use crate::ai_serving::planner::candidate_materialization::LocalExecutionCandidateAttempt as LocalOpenAiChatCandidateAttempt;
 pub(crate) use crate::ai_serving::planner::candidate_materialization::LocalExecutionCandidateAttemptSource as LocalOpenAiChatCandidateAttemptSource;
@@ -357,95 +354,3 @@ pub(crate) async fn build_lazy_local_openai_chat_candidate_attempt_source<'a>(
     )
     .await
 }
-
-pub(crate) async fn build_local_openai_chat_image_candidate_attempt_source<'a>(
-    state: &'a AppState,
-    trace_id: &str,
-    input: &LocalOpenAiChatDecisionInput,
-    body_json: &serde_json::Value,
-) -> Result<(LocalOpenAiChatCandidateAttemptSource<'a>, usize), GatewayError> {
-    let planner_state = PlannerAppState::new(state);
-    let sticky_session_token = extract_pool_sticky_session_token(body_json);
-    let auth_context: &ExecutionRuntimeAuthContext = &input.auth_context;
-    let persistence_policy = build_local_candidate_persistence_policy(
-        auth_context,
-        input.required_capabilities.as_ref(),
-        LocalCandidatePersistencePolicyKind::OpenAiChatDecision,
-    );
-    let preselection = preselect_local_execution_candidates_for_api_formats_with_serving(
-        planner_state,
-        "openai:chat",
-        &input.requested_model,
-        false,
-        input.required_capabilities.as_ref(),
-        &input.auth_snapshot,
-        input.routing_policy.as_ref(),
-        input.client_session_affinity.as_ref(),
-        false,
-        LocalCandidatePreselectionKeyMode::ProviderEndpointKeyModelAndApiFormat,
-        vec!["openai:image".to_string()],
-    )
-    .await?;
-
-    Ok(build_local_execution_candidate_attempt_source_with_serving(
-        planner_state,
-        trace_id,
-        "openai:chat",
-        Some(&input.requested_model),
-        Some(&input.auth_snapshot),
-        input.client_session_affinity.as_ref(),
-        input.required_capabilities.as_ref(),
-        input.routing_policy.as_ref(),
-        sticky_session_token.as_deref(),
-        input.request_auth_channel.as_deref(),
-        persistence_policy,
-        preselection.candidates,
-        preselection.skipped_candidates,
-        LocalCandidateResolutionMode::WithoutTransportPairGate,
-        |eligible| {
-            let provider_api_format = eligible.provider_api_format.clone();
-            let (execution_strategy, conversion_mode) =
-                ai_local_execution_contract_for_formats("openai:chat", &provider_api_format);
-            Some(build_local_execution_candidate_contract_metadata(
-                LocalExecutionCandidateMetadataParts {
-                    eligible,
-                    provider_api_format: provider_api_format.as_str(),
-                    client_api_format: "openai:chat",
-                    extra_fields: serde_json::Map::new(),
-                },
-                execution_strategy,
-                conversion_mode,
-                eligible.candidate.endpoint_api_format.trim(),
-            ))
-        },
-        |mut skipped_candidate| {
-            let provider_api_format = skipped_candidate
-                .transport
-                .as_ref()
-                .map(|transport| transport.endpoint.api_format.trim().to_ascii_lowercase())
-                .unwrap_or_else(|| {
-                    skipped_candidate
-                        .candidate
-                        .endpoint_api_format
-                        .trim()
-                        .to_ascii_lowercase()
-                });
-            let (execution_strategy, conversion_mode) =
-                ai_local_execution_contract_for_formats("openai:chat", &provider_api_format);
-            skipped_candidate.extra_data = Some(
-                build_local_execution_candidate_contract_metadata_for_candidate(
-                    &skipped_candidate.candidate,
-                    skipped_candidate.transport_ref(),
-                    provider_api_format.as_str(),
-                    "openai:chat",
-                    serde_json::Map::new(),
-                    execution_strategy,
-                    conversion_mode,
-                    provider_api_format.as_str(),
-                ),
-            );
-            skipped_candidate
-        },
-    )
-    .await)
-}

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

@@ -11,7 +11,6 @@ mod plans;
 
 use self::decision::{
     build_lazy_local_openai_chat_candidate_attempt_source,
-    build_local_openai_chat_image_candidate_attempt_source,
     maybe_build_local_openai_chat_decision_payload_for_candidate, LocalOpenAiChatCandidateAttempt,
     LocalOpenAiChatCandidateAttemptSource, LocalOpenAiChatDecisionInput,
 };

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

@@ -1,10 +1,8 @@
 use async_trait::async_trait;
 use tracing::warn;
 
-use super::super::super::openai_request_is_image_generation_intent;
 use super::super::{
     build_lazy_local_openai_chat_candidate_attempt_source,
-    build_local_openai_chat_image_candidate_attempt_source,
     maybe_build_local_openai_chat_decision_payload_for_candidate, AppState, GatewayControlDecision,
     GatewayError, LocalOpenAiChatCandidateAttempt, LocalOpenAiChatCandidateAttemptSource,
     LocalOpenAiChatDecisionInput,
@@ -51,53 +49,14 @@ pub(crate) async fn build_local_openai_chat_stream_attempt_source<'a>(
     };
     let effective_body_json = input.effective_body_json(body_json).clone();
 
-    let image_generation_intent =
+    let (candidates, candidate_count) = build_lazy_local_openai_chat_candidate_attempt_source(
-        openai_request_is_image_generation_intent(&input.requested_model, body_json);
+        state,
-    let (mut candidates, mut candidate_count) = if image_generation_intent {
+        trace_id,
-        let (image_candidates, image_candidate_count) =
+        &input,
-            build_local_openai_chat_image_candidate_attempt_source(
+        &effective_body_json,
-                state,
+        true,
-                trace_id,
+    )
-                &input,
+    .await;
-                &effective_body_json,
-            )
-            .await?;
-        if image_candidate_count > 0 {
-            (image_candidates, image_candidate_count)
-        } else {
-            build_lazy_local_openai_chat_candidate_attempt_source(
-                state,
-                trace_id,
-                &input,
-                &effective_body_json,
-                true,
-            )
-            .await
-        }
-    } else {
-        build_lazy_local_openai_chat_candidate_attempt_source(
-            state,
-            trace_id,
-            &input,
-            &effective_body_json,
-            true,
-        )
-        .await
-    };
-    if !image_generation_intent && candidate_count == 0 {
-        let (image_candidates, image_candidate_count) =
-            build_local_openai_chat_image_candidate_attempt_source(
-                state,
-                trace_id,
-                &input,
-                &effective_body_json,
-            )
-            .await?;
-        if image_candidate_count > 0 {
-            candidates = image_candidates;
-            candidate_count = image_candidate_count;
-        }
-    }
     if candidate_count == 0 {
         set_local_openai_chat_candidate_evaluation_diagnostic(
             state,

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

@@ -0,0 +1,55 @@
+use serde_json::Value;
+
+pub(super) fn openai_request_is_image_generation_intent(
+    _requested_model: &str,
+    body_json: &Value,
+) -> bool {
+    request_forces_image_generation_tool(body_json)
+}
+
+fn request_forces_image_generation_tool(body_json: &Value) -> bool {
+    body_json
+        .get("tool_choice")
+        .is_some_and(value_is_image_generation_tool)
+}
+
+fn value_is_image_generation_tool(value: &Value) -> bool {
+    value
+        .get("type")
+        .and_then(Value::as_str)
+        .is_some_and(|tool_type| tool_type.trim().eq_ignore_ascii_case("image_generation"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn tools_declaration_without_tool_choice_does_not_trigger_image_generation() {
+        let body_json = serde_json::json!({
+            "model": "gpt-image-2",
+            "input": "Draw a mountain observatory",
+            "tools": [{"type": "image_generation"}]
+        });
+
+        assert!(!openai_request_is_image_generation_intent(
+            "gpt-image-2",
+            &body_json
+        ));
+    }
+
+    #[test]
+    fn explicit_image_generation_tool_choice_triggers_image_generation() {
+        let body_json = serde_json::json!({
+            "model": "gpt-image-2",
+            "input": "Draw a mountain observatory",
+            "tools": [{"type": "image_generation"}],
+            "tool_choice": {"type": "image_generation"}
+        });
+
+        assert!(openai_request_is_image_generation_intent(
+            "gpt-image-2",
+            &body_json
+        ));
+    }
+}

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

@@ -113,13 +113,8 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
         .provider_type
         .trim()
         .eq_ignore_ascii_case("grok");
-    let is_codex = transport
-        .provider
-        .provider_type
-        .trim()
-        .eq_ignore_ascii_case("codex");
 
-    if is_codex && provider_api_format.eq_ignore_ascii_case("openai:image") {
+    if !is_grok && provider_api_format.eq_ignore_ascii_case("openai:image") {
         return resolve_openai_responses_to_openai_image_payload_parts(
             state,
             parts,

apps/aether-gateway/src/tests/ai_execute/stream/image.rs

@@ -13,7 +13,6 @@ use aether_data::repository::provider_catalog::InMemoryProviderCatalogReadReposi
 use aether_data_contracts::repository::candidate_selection::{
     StoredMinimalCandidateSelectionRow, StoredProviderModelMapping,
 };
-use aether_data_contracts::repository::candidates::RequestCandidateReadRepository;
 use aether_data_contracts::repository::provider_catalog::{
     StoredProviderCatalogEndpoint, StoredProviderCatalogKey, StoredProviderCatalogProvider,
 };
@@ -751,7 +750,6 @@ struct SeenImageBridgeExecutionPlan {
     url: String,
     plan_stream: bool,
     auth_header: String,
-    chatgpt_web_marker: String,
     body_json: serde_json::Value,
 }
 
@@ -1017,12 +1015,6 @@ fn capture_image_bridge_execution_plan(
             .and_then(|value| value.as_str())
             .unwrap_or_default()
             .to_string(),
-        chatgpt_web_marker: payload
-            .get("headers")
-            .and_then(|value| value.get("x-aether-chatgpt-web-image"))
-            .and_then(|value| value.as_str())
-            .unwrap_or_default()
-            .to_string(),
         body_json: payload
             .get("body")
             .and_then(|value| value.get("json_body"))
@@ -1065,74 +1057,6 @@ fn image_bridge_execution_runtime(
     )
 }
 
-#[tokio::test]
-async fn gateway_routes_openai_chat_stream_image_intent_to_openai_image_plan_without_streaming_support(
-) {
-    let seen_execution_plan = Arc::new(Mutex::new(None::<SeenImageBridgeExecutionPlan>));
-    let execution_runtime = image_bridge_execution_runtime(Arc::clone(&seen_execution_plan));
-    let (execution_runtime_url, execution_runtime_handle) = start_server(execution_runtime).await;
-    let (gateway_url, gateway_handle, client_api_key, request_candidate_repository) =
-        start_image_bridge_gateway(
-            "chat-stream-image-bridge",
-            "image-provider",
-            "custom",
-            "https://images.example.com",
-            execution_runtime_url,
-        )
-        .await;
-
-    let response = reqwest::Client::new()
-        .post(format!("{gateway_url}/v1/chat/completions"))
-        .header(http::header::CONTENT_TYPE, "application/json")
-        .header(http::header::AUTHORIZATION, format!("Bearer {client_api_key}"))
-        .header(TRACE_ID_HEADER, "trace-chat-stream-image-bridge-123")
-        .body(
-            r#"{"model":"gpt-image-2","messages":[{"role":"user","content":"Draw a city made of glass"}],"stream":true,"size":"1024x1024"}"#,
-        )
-        .send()
-        .await
-        .expect("request should succeed");
-
-    let status = response.status();
-    let response_text = response.text().await.expect("body should read");
-    let stored_candidates = request_candidate_repository
-        .list_by_request_id("trace-chat-stream-image-bridge-123")
-        .await
-        .expect("request candidates should read");
-    assert_eq!(
-        status,
-        StatusCode::OK,
-        "{response_text}\n{stored_candidates:#?}"
-    );
-    assert!(response_text.contains("\"object\":\"chat.completion.chunk\""));
-    assert!(response_text.contains("![generated image](data:image/png;base64,aGVsbG8=)"));
-    assert!(response_text.contains("data: [DONE]"));
-    assert!(!response_text.contains("image_generation.completed"));
-
-    let seen_plan = seen_execution_plan
-        .lock()
-        .expect("mutex should lock")
-        .clone()
-        .expect("execution plan should be captured");
-    assert_eq!(seen_plan.trace_id, "trace-chat-stream-image-bridge-123");
-    assert_eq!(seen_plan.client_api_format, "openai:chat");
-    assert_eq!(seen_plan.provider_api_format, "openai:image");
-    assert_eq!(seen_plan.url, "https://images.example.com/v1/responses");
-    assert!(seen_plan.plan_stream);
-    assert_eq!(seen_plan.auth_header, "Bearer sk-upstream-image-bridge");
-    assert_eq!(seen_plan.chatgpt_web_marker, "");
-    assert_eq!(seen_plan.body_json["model"], "gpt-image-2");
-    assert_eq!(seen_plan.body_json["stream"], true);
-    assert_eq!(
-        seen_plan.body_json["input"][0]["content"],
-        "Draw a city made of glass"
-    );
-    assert!(seen_plan.body_json.get("tools").is_none());
-
-    gateway_handle.abort();
-    execution_runtime_handle.abort();
-}
-
 #[tokio::test]
 async fn gateway_routes_openai_responses_stream_image_intent_to_openai_image_plan_without_streaming_support(
 ) {
@@ -1155,7 +1079,7 @@ async fn gateway_routes_openai_responses_stream_image_intent_to_openai_image_pla
         .header(http::header::AUTHORIZATION, format!("Bearer {client_api_key}"))
         .header(TRACE_ID_HEADER, "trace-responses-stream-image-bridge-123")
         .body(
-            r#"{"model":"gpt-image-2","input":"Draw a mountain observatory","tools":[{"type":"image_generation","size":"1024x1024"}],"stream":true}"#,
+            r#"{"model":"gpt-image-2","input":"Draw a mountain observatory","tools":[{"type":"image_generation","size":"1024x1024"}],"tool_choice":{"type":"image_generation"},"stream":true}"#,
         )
         .send()
         .await