i/Aether
1
0
Fork 0
mirror of https://github.com/fawney19/Aether.git synced 2026-09-10 21:20:20 +08:00
Code Issues Packages Projects Releases Wiki Activity

Refactor Gemini CLI v1internal planner request builder

Browse Source
This commit is contained in:
Mas0nShi
2026-05-22 18:57:03 +08:00
parent 8cc6888c5b
commit 0d80db8a8d
4 changed files with 360 additions and 342 deletions
Download Patch File Download Diff File Expand all files Collapse all files
apps/aether-gateway/src/ai_serving/planner/gemini_cli.rs
+86 -12
View File
@@ -1,31 +1,105 @@
use std::collections::BTreeMap;
use std::sync::Arc;
use serde_json::Value;
use crate::ai_serving::transport::gemini_cli::resolve_gemini_cli_project_id;
use crate::ai_serving::transport::{
build_gemini_cli_v1internal_request, GatewayProviderTransportSnapshot,
GeminiCliRequestEnvelopeSupport,
build_gemini_cli_v1internal_request, build_standard_provider_request_headers,
GatewayProviderTransportSnapshot, GeminiCliRequestEnvelopeSupport,
StandardProviderRequestHeaders, StandardProviderRequestHeadersInput, GEMINI_CLI_USER_AGENT,
};
use crate::AppState;
pub(crate) struct GeminiCliV1InternalPayload {
pub(crate) transport: Arc<GatewayProviderTransportSnapshot>,
pub(crate) body: Value,
}
pub(crate) enum GeminiCliV1InternalPayloadError {
pub(crate) enum GeminiCliV1InternalRequestError {
ProjectUnavailable,
EnvelopeUnsupported,
UpstreamUrlUnavailable,
HeaderRulesApplyFailed,
}
pub(crate) async fn build_gemini_cli_v1internal_payload(
pub(crate) struct GeminiCliV1InternalRequestInput<'a> {
pub(crate) state: &'a AppState,
pub(crate) parts: &'a http::request::Parts,
pub(crate) transport: &'a Arc<GatewayProviderTransportSnapshot>,
pub(crate) trace_id: &'a str,
pub(crate) mapped_model: &'a str,
pub(crate) provider_api_format: &'a str,
pub(crate) auth_header: &'a str,
pub(crate) auth_value: &'a str,
pub(crate) request_headers: &'a http::HeaderMap,
pub(crate) original_request_body: &'a Value,
pub(crate) gemini_request_body: &'a Value,
pub(crate) upstream_is_stream: bool,
}
pub(crate) struct GeminiCliV1InternalRequest {
pub(crate) transport: Arc<GatewayProviderTransportSnapshot>,
pub(crate) body: Value,
pub(crate) headers: StandardProviderRequestHeaders,
pub(crate) upstream_url: String,
}
pub(crate) async fn build_gemini_cli_v1internal_provider_request(
input: GeminiCliV1InternalRequestInput<'_>,
) -> Result<GeminiCliV1InternalRequest, GeminiCliV1InternalRequestError> {
let payload = build_gemini_cli_v1internal_payload(
input.state,
input.transport,
input.trace_id,
input.mapped_model,
input.gemini_request_body,
)
.await?;
let upstream_url = crate::ai_serving::build_provider_transport_request_url_for_request_body(
&payload.transport,
input.provider_api_format,
Some(input.mapped_model),
input.upstream_is_stream,
input.parts.uri.query(),
None,
Some(&payload.body),
)
.ok_or(GeminiCliV1InternalRequestError::UpstreamUrlUnavailable)?;
let extra_headers =
BTreeMap::from([("user-agent".to_string(), GEMINI_CLI_USER_AGENT.to_string())]);
let headers = build_standard_provider_request_headers(StandardProviderRequestHeadersInput {
transport: &payload.transport,
provider_api_format: input.provider_api_format,
same_format: false,
headers: input.request_headers,
auth_header: input.auth_header,
auth_value: input.auth_value,
extra_headers: &extra_headers,
header_rules: payload.transport.endpoint.header_rules.as_ref(),
provider_request_body: &payload.body,
original_request_body: input.original_request_body,
upstream_is_stream: input.upstream_is_stream,
})
.ok_or(GeminiCliV1InternalRequestError::HeaderRulesApplyFailed)?;
Ok(GeminiCliV1InternalRequest {
transport: payload.transport,
body: payload.body,
headers,
upstream_url,
})
}
struct GeminiCliV1InternalPayload {
transport: Arc<GatewayProviderTransportSnapshot>,
body: Value,
}
async fn build_gemini_cli_v1internal_payload(
state: &AppState,
transport: &Arc<GatewayProviderTransportSnapshot>,
trace_id: &str,
mapped_model: &str,
gemini_request_body: &Value,
) -> Result<GeminiCliV1InternalPayload, GeminiCliV1InternalPayloadError> {
) -> Result<GeminiCliV1InternalPayload, GeminiCliV1InternalRequestError> {
let mut resolved_transport = Arc::clone(transport);
let project_id = match resolve_gemini_cli_project_id(&resolved_transport) {
Some(project_id) => Some(project_id),
@@ -41,7 +115,7 @@ pub(crate) async fn build_gemini_cli_v1internal_payload(
None => None,
},
}
.ok_or(GeminiCliV1InternalPayloadError::ProjectUnavailable)?;
.ok_or(GeminiCliV1InternalRequestError::ProjectUnavailable)?;
let body = match build_gemini_cli_v1internal_request(
&project_id,
@@ -51,7 +125,7 @@ pub(crate) async fn build_gemini_cli_v1internal_payload(
) {
GeminiCliRequestEnvelopeSupport::Supported(envelope) => envelope,
GeminiCliRequestEnvelopeSupport::Unsupported(_) => {
return Err(GeminiCliV1InternalPayloadError::EnvelopeUnsupported);
return Err(GeminiCliV1InternalRequestError::EnvelopeUnsupported);
}
};
apps/aether-gateway/src/ai_serving/planner/standard/family/request.rs
+93 -114
View File
@@ -13,7 +13,8 @@ use crate::ai_serving::planner::common::{
request_requires_body_stream_field, resolve_upstream_is_stream_for_provider,
};
use crate::ai_serving::planner::gemini_cli::{
build_gemini_cli_v1internal_payload, GeminiCliV1InternalPayloadError,
build_gemini_cli_v1internal_provider_request, GeminiCliV1InternalRequestError,
GeminiCliV1InternalRequestInput,
};
use crate::ai_serving::planner::spec_metadata::local_standard_spec_metadata;
use crate::ai_serving::planner::standard::{
@@ -33,8 +34,8 @@ use crate::ai_serving::transport::{
local_windsurf_request_transport_unsupported_reason_with_network,
openai_image_transport_unsupported_reason, resolve_grok_session_auth,
resolve_openai_image_auth, GrokHeaderInput, ProviderOpenAiImageHeadersInput,
StandardProviderRequestHeadersInput, GEMINI_CLI_USER_AGENT,
GEMINI_CLI_V1INTERNAL_ENVELOPE_NAME, GROK_CHAT_PATH, WINDSURF_ENVELOPE_NAME,
StandardProviderRequestHeadersInput, GEMINI_CLI_V1INTERNAL_ENVELOPE_NAME, GROK_CHAT_PATH,
WINDSURF_ENVELOPE_NAME,
};
use crate::ai_serving::{
build_openai_image_request_body_from_gemini_image_request, gemini_request_is_image_generation,
@@ -756,137 +757,115 @@ async fn build_gemini_cli_cross_format_payload_parts(
) -> Option<LocalStandardCandidatePayloadParts> {
let candidate = &attempt.eligible.candidate;
let effective_headers = input.effective_headers(&parts.headers);
let resolved = match build_gemini_cli_v1internal_payload(
state,
transport,
trace_id,
&mapped_model,
&gemini_request_body,
)
.await
{
Ok(resolved) => resolved,
Err(GeminiCliV1InternalPayloadError::ProjectUnavailable) => {
mark_skipped_local_standard_candidate(
state,
input,
trace_id,
candidate,
attempt.candidate_index,
&attempt.candidate_id,
"transport_auth_unavailable",
)
.await;
return None;
}
Err(GeminiCliV1InternalPayloadError::EnvelopeUnsupported) => {
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_body_build_failure_extra_data(
original_body_json,
client_api_format,
provider_api_format,
),
)
.await;
return None;
}
};
let provider_request_body = resolved.body;
let resolved_transport = resolved.transport;
let upstream_url = match crate::ai_serving::planner::standard::build_standard_upstream_url(
parts,
&resolved_transport,
&mapped_model,
provider_api_format,
upstream_is_stream,
Some(&provider_request_body),
) {
Some(url) => url,
None => {
mark_skipped_local_standard_candidate_with_failure_diagnostic(
state,
input,
trace_id,
candidate,
attempt.candidate_index,
&attempt.candidate_id,
"upstream_url_missing",
CandidateFailureDiagnostic::upstream_url_missing(
client_api_format,
provider_api_format,
"standard_family_gemini_cli_url",
),
)
.await;
return None;
}
};
let extra_headers =
BTreeMap::from([("user-agent".to_string(), GEMINI_CLI_USER_AGENT.to_string())]);
let Some(resolved_headers) =
build_standard_provider_request_headers(StandardProviderRequestHeadersInput {
transport: &resolved_transport,
let resolved =
match build_gemini_cli_v1internal_provider_request(GeminiCliV1InternalRequestInput {
state,
parts,
transport,
trace_id,
mapped_model: &mapped_model,
provider_api_format,
same_format: false,
headers: effective_headers,
auth_header: &auth_header,
auth_value: &auth_value,
extra_headers: &extra_headers,
header_rules: resolved_transport.endpoint.header_rules.as_ref(),
provider_request_body: &provider_request_body,
request_headers: effective_headers,
original_request_body: original_body_json,
gemini_request_body: &gemini_request_body,
upstream_is_stream,
})
else {
mark_skipped_local_standard_candidate_with_failure_diagnostic(
state,
input,
trace_id,
candidate,
attempt.candidate_index,
&attempt.candidate_id,
"transport_header_rules_apply_failed",
CandidateFailureDiagnostic::header_rules_apply_failed(
client_api_format,
provider_api_format,
"standard_family_gemini_cli_headers",
),
)
.await;
return None;
};
.await
{
Ok(resolved) => resolved,
Err(GeminiCliV1InternalRequestError::ProjectUnavailable) => {
mark_skipped_local_standard_candidate(
state,
input,
trace_id,
candidate,
attempt.candidate_index,
&attempt.candidate_id,
"transport_auth_unavailable",
)
.await;
return None;
}
Err(GeminiCliV1InternalRequestError::EnvelopeUnsupported) => {
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_body_build_failure_extra_data(
original_body_json,
client_api_format,
provider_api_format,
),
)
.await;
return None;
}
Err(GeminiCliV1InternalRequestError::UpstreamUrlUnavailable) => {
mark_skipped_local_standard_candidate_with_failure_diagnostic(
state,
input,
trace_id,
candidate,
attempt.candidate_index,
&attempt.candidate_id,
"upstream_url_missing",
CandidateFailureDiagnostic::upstream_url_missing(
client_api_format,
provider_api_format,
"standard_family_gemini_cli_url",
),
)
.await;
return None;
}
Err(GeminiCliV1InternalRequestError::HeaderRulesApplyFailed) => {
mark_skipped_local_standard_candidate_with_failure_diagnostic(
state,
input,
trace_id,
candidate,
attempt.candidate_index,
&attempt.candidate_id,
"transport_header_rules_apply_failed",
CandidateFailureDiagnostic::header_rules_apply_failed(
client_api_format,
provider_api_format,
"standard_family_gemini_cli_headers",
),
)
.await;
return None;
}
};
let mut provider_request_headers = resolved_headers.headers;
let mut provider_request_headers = resolved.headers.headers;
apply_codex_openai_responses_special_headers(
&mut provider_request_headers,
&provider_request_body,
&resolved.body,
effective_headers,
resolved_transport.provider.provider_type.as_str(),
resolved.transport.provider.provider_type.as_str(),
provider_api_format,
Some(trace_id),
resolved_transport.key.decrypted_auth_config.as_deref(),
resolved.transport.key.decrypted_auth_config.as_deref(),
);
Some(LocalStandardCandidatePayloadParts {
auth_header: resolved_headers.auth_header,
auth_value: resolved_headers.auth_value,
auth_header: resolved.headers.auth_header,
auth_value: resolved.headers.auth_value,
mapped_model,
provider_api_format: provider_api_format.to_string(),
provider_request_body,
provider_request_body: resolved.body,
provider_request_headers,
upstream_url,
upstream_url: resolved.upstream_url,
upstream_is_stream,
envelope_name: Some(GEMINI_CLI_V1INTERNAL_ENVELOPE_NAME),
transport: resolved_transport,
transport: resolved.transport,
transport_profile: None,
})
}
apps/aether-gateway/src/ai_serving/planner/standard/openai/chat/decision/request.rs
+91 -108
View File
@@ -16,7 +16,8 @@ use crate::ai_serving::planner::common::{
request_requires_body_stream_field, OPENAI_CHAT_STREAM_PLAN_KIND,
};
use crate::ai_serving::planner::gemini_cli::{
build_gemini_cli_v1internal_payload, GeminiCliV1InternalPayloadError,
build_gemini_cli_v1internal_provider_request, GeminiCliV1InternalRequestError,
GeminiCliV1InternalRequestInput,
};
use crate::ai_serving::planner::standard::{
apply_codex_openai_responses_special_body_edits, apply_codex_openai_responses_special_headers,
@@ -42,7 +43,7 @@ use crate::ai_serving::transport::{
build_openai_image_headers, build_openai_image_upstream_url,
build_standard_provider_request_headers, is_gemini_cli_provider_transport,
openai_image_transport_unsupported_reason, resolve_openai_image_auth, GrokHeaderInput,
ProviderOpenAiImageHeadersInput, StandardProviderRequestHeadersInput, GEMINI_CLI_USER_AGENT,
ProviderOpenAiImageHeadersInput, StandardProviderRequestHeadersInput,
GEMINI_CLI_V1INTERNAL_ENVELOPE_NAME, GROK_CHAT_PATH,
};
use crate::ai_serving::{
@@ -881,119 +882,101 @@ async fn build_gemini_cli_openai_chat_cross_format_payload_parts(
) -> Option<LocalOpenAiChatCandidatePayloadParts> {
let candidate = &eligible.candidate;
let effective_headers = input.effective_headers(&parts.headers);
let resolved = match build_gemini_cli_v1internal_payload(
state,
transport,
trace_id,
&mapped_model,
&gemini_request_body,
)
.await
{
Ok(resolved) => resolved,
Err(GeminiCliV1InternalPayloadError::ProjectUnavailable) => {
mark_skipped_local_openai_chat_candidate(
state,
input,
trace_id,
candidate,
candidate_index,
candidate_id,
"transport_auth_unavailable",
)
.await;
return None;
}
Err(GeminiCliV1InternalPayloadError::EnvelopeUnsupported) => {
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(
original_body_json,
"openai:chat",
provider_api_format,
),
)
.await;
return None;
}
};
let provider_request_body = resolved.body;
let resolved_transport = resolved.transport;
let Some(upstream_url) = build_cross_format_openai_chat_upstream_url(
parts,
&resolved_transport,
&mapped_model,
provider_api_format,
upstream_is_stream,
) else {
mark_skipped_local_openai_chat_candidate_with_failure_diagnostic(
let resolved =
match build_gemini_cli_v1internal_provider_request(GeminiCliV1InternalRequestInput {
state,
input,
parts,
transport,
trace_id,
candidate,
candidate_index,
candidate_id,
"upstream_url_missing",
CandidateFailureDiagnostic::upstream_url_missing(
"openai:chat",
provider_api_format,
"openai_chat_gemini_cli_url",
),
)
.await;
return None;
};
let extra_headers =
BTreeMap::from([("user-agent".to_string(), GEMINI_CLI_USER_AGENT.to_string())]);
let Some(resolved_headers) =
build_standard_provider_request_headers(StandardProviderRequestHeadersInput {
transport: &resolved_transport,
mapped_model: &mapped_model,
provider_api_format,
same_format: false,
headers: effective_headers,
auth_header: &auth_header,
auth_value: &auth_value,
extra_headers: &extra_headers,
header_rules: resolved_transport.endpoint.header_rules.as_ref(),
provider_request_body: &provider_request_body,
request_headers: effective_headers,
original_request_body: original_body_json,
gemini_request_body: &gemini_request_body,
upstream_is_stream,
})
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_gemini_cli_headers",
),
)
.await;
return None;
};
let mut provider_request_headers = resolved_headers.headers;
.await
{
Ok(resolved) => resolved,
Err(GeminiCliV1InternalRequestError::ProjectUnavailable) => {
mark_skipped_local_openai_chat_candidate(
state,
input,
trace_id,
candidate,
candidate_index,
candidate_id,
"transport_auth_unavailable",
)
.await;
return None;
}
Err(GeminiCliV1InternalRequestError::EnvelopeUnsupported) => {
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(
original_body_json,
"openai:chat",
provider_api_format,
),
)
.await;
return None;
}
Err(GeminiCliV1InternalRequestError::UpstreamUrlUnavailable) => {
mark_skipped_local_openai_chat_candidate_with_failure_diagnostic(
state,
input,
trace_id,
candidate,
candidate_index,
candidate_id,
"upstream_url_missing",
CandidateFailureDiagnostic::upstream_url_missing(
"openai:chat",
provider_api_format,
"openai_chat_gemini_cli_url",
),
)
.await;
return None;
}
Err(GeminiCliV1InternalRequestError::HeaderRulesApplyFailed) => {
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_gemini_cli_headers",
),
)
.await;
return None;
}
};
let mut provider_request_headers = resolved.headers.headers;
apply_codex_openai_responses_special_headers(
&mut provider_request_headers,
&provider_request_body,
&resolved.body,
effective_headers,
resolved_transport.provider.provider_type.as_str(),
resolved.transport.provider.provider_type.as_str(),
provider_api_format,
Some(trace_id),
resolved_transport.key.decrypted_auth_config.as_deref(),
resolved.transport.key.decrypted_auth_config.as_deref(),
);
request_identity_response_encoding_when_redacted(
&mut provider_request_headers,
@@ -1010,18 +993,18 @@ async fn build_gemini_cli_openai_chat_cross_format_payload_parts(
Some(LocalOpenAiChatCandidatePayloadParts {
client_api_format: "openai:chat".to_string(),
auth_header: resolved_headers.auth_header,
auth_value: resolved_headers.auth_value,
auth_header: resolved.headers.auth_header,
auth_value: resolved.headers.auth_value,
mapped_model,
provider_api_format: provider_api_format.to_string(),
provider_request_body,
provider_request_body: resolved.body,
provider_request_headers,
upstream_url,
upstream_url: resolved.upstream_url,
execution_strategy,
conversion_mode,
report_kind: resolved_report_kind,
envelope_name: Some(GEMINI_CLI_V1INTERNAL_ENVELOPE_NAME),
transport: resolved_transport,
transport: resolved.transport,
request_redacted,
transport_profile: None,
image_request_summary: None,
@@ -2072,7 +2055,7 @@ mod tests {
.provider_request_headers
.get("user-agent")
.map(String::as_str),
Some(GEMINI_CLI_USER_AGENT)
Some(crate::ai_serving::transport::GEMINI_CLI_USER_AGENT)
);
assert_eq!(payload.provider_request_body["model"], "gemini-2.5-pro");
assert_eq!(payload.provider_request_body["project"], "test-project");
apps/aether-gateway/src/ai_serving/planner/standard/openai/responses/decision/request.rs
+90 -108
View File
@@ -15,7 +15,8 @@ use crate::ai_serving::planner::common::{
request_requires_body_stream_field, resolve_upstream_is_stream_for_provider,
};
use crate::ai_serving::planner::gemini_cli::{
build_gemini_cli_v1internal_payload, GeminiCliV1InternalPayloadError,
build_gemini_cli_v1internal_provider_request, GeminiCliV1InternalRequestError,
GeminiCliV1InternalRequestInput,
};
use crate::ai_serving::planner::spec_metadata::local_openai_responses_spec_metadata;
use crate::ai_serving::planner::standard::{
@@ -48,7 +49,7 @@ use crate::ai_serving::transport::{
local_standard_transport_unsupported_reason_with_network,
local_windsurf_request_transport_unsupported_reason_with_network,
openai_image_transport_unsupported_reason, resolve_openai_image_auth, GrokHeaderInput,
ProviderOpenAiImageHeadersInput, StandardProviderRequestHeadersInput, GEMINI_CLI_USER_AGENT,
ProviderOpenAiImageHeadersInput, StandardProviderRequestHeadersInput,
GEMINI_CLI_V1INTERNAL_ENVELOPE_NAME, GROK_CHAT_PATH, WINDSURF_ENVELOPE_NAME,
};
use crate::ai_serving::{
@@ -695,139 +696,120 @@ async fn build_gemini_cli_openai_responses_payload_parts(
) -> Option<LocalOpenAiResponsesCandidatePayloadParts> {
let candidate = &eligible.candidate;
let effective_headers = input.effective_headers(&parts.headers);
let resolved = match build_gemini_cli_v1internal_payload(
state,
transport,
trace_id,
&mapped_model,
&gemini_request_body,
)
.await
{
Ok(resolved) => resolved,
Err(GeminiCliV1InternalPayloadError::ProjectUnavailable) => {
mark_skipped_local_openai_responses_candidate(
state,
input,
trace_id,
candidate,
candidate_index,
candidate_id,
"transport_auth_unavailable",
)
.await;
return None;
}
Err(GeminiCliV1InternalPayloadError::EnvelopeUnsupported) => {
mark_skipped_local_openai_responses_candidate_with_extra_data(
state,
input,
trace_id,
candidate,
candidate_index,
candidate_id,
"provider_request_body_build_failed",
request_body_build_failure_extra_data(
original_body_json,
client_api_format,
provider_api_format,
),
)
.await;
return None;
}
};
let provider_request_body = resolved.body;
let resolved_transport = resolved.transport;
let Some(upstream_url) = build_cross_format_openai_responses_upstream_url(
parts,
&resolved_transport,
&mapped_model,
client_api_format,
provider_api_format,
upstream_is_stream,
) else {
mark_skipped_local_openai_responses_candidate_with_failure_diagnostic(
let resolved =
match build_gemini_cli_v1internal_provider_request(GeminiCliV1InternalRequestInput {
state,
input,
parts,
transport,
trace_id,
candidate,
candidate_index,
candidate_id,
"upstream_url_missing",
CandidateFailureDiagnostic::upstream_url_missing(
client_api_format,
provider_api_format,
"openai_responses_gemini_cli_url",
),
)
.await;
return None;
};
let extra_headers =
BTreeMap::from([("user-agent".to_string(), GEMINI_CLI_USER_AGENT.to_string())]);
let Some(resolved_headers) =
build_standard_provider_request_headers(StandardProviderRequestHeadersInput {
transport: &resolved_transport,
mapped_model: &mapped_model,
provider_api_format,
same_format: false,
headers: effective_headers,
auth_header: &auth_header,
auth_value: &auth_value,
extra_headers: &extra_headers,
header_rules: resolved_transport.endpoint.header_rules.as_ref(),
provider_request_body: &provider_request_body,
request_headers: effective_headers,
original_request_body: original_body_json,
gemini_request_body: &gemini_request_body,
upstream_is_stream,
})
else {
mark_skipped_local_openai_responses_candidate_with_failure_diagnostic(
state,
input,
trace_id,
candidate,
candidate_index,
candidate_id,
"transport_header_rules_apply_failed",
CandidateFailureDiagnostic::header_rules_apply_failed(
client_api_format,
provider_api_format,
"openai_responses_gemini_cli_headers",
),
)
.await;
return None;
};
let mut provider_request_headers = resolved_headers.headers;
.await
{
Ok(resolved) => resolved,
Err(GeminiCliV1InternalRequestError::ProjectUnavailable) => {
mark_skipped_local_openai_responses_candidate(
state,
input,
trace_id,
candidate,
candidate_index,
candidate_id,
"transport_auth_unavailable",
)
.await;
return None;
}
Err(GeminiCliV1InternalRequestError::EnvelopeUnsupported) => {
mark_skipped_local_openai_responses_candidate_with_extra_data(
state,
input,
trace_id,
candidate,
candidate_index,
candidate_id,
"provider_request_body_build_failed",
request_body_build_failure_extra_data(
original_body_json,
client_api_format,
provider_api_format,
),
)
.await;
return None;
}
Err(GeminiCliV1InternalRequestError::UpstreamUrlUnavailable) => {
mark_skipped_local_openai_responses_candidate_with_failure_diagnostic(
state,
input,
trace_id,
candidate,
candidate_index,
candidate_id,
"upstream_url_missing",
CandidateFailureDiagnostic::upstream_url_missing(
client_api_format,
provider_api_format,
"openai_responses_gemini_cli_url",
),
)
.await;
return None;
}
Err(GeminiCliV1InternalRequestError::HeaderRulesApplyFailed) => {
mark_skipped_local_openai_responses_candidate_with_failure_diagnostic(
state,
input,
trace_id,
candidate,
candidate_index,
candidate_id,
"transport_header_rules_apply_failed",
CandidateFailureDiagnostic::header_rules_apply_failed(
client_api_format,
provider_api_format,
"openai_responses_gemini_cli_headers",
),
)
.await;
return None;
}
};
let mut provider_request_headers = resolved.headers.headers;
apply_codex_openai_responses_special_headers(
&mut provider_request_headers,
&provider_request_body,
&resolved.body,
effective_headers,
resolved_transport.provider.provider_type.as_str(),
resolved.transport.provider.provider_type.as_str(),
provider_api_format,
Some(trace_id),
resolved_transport.key.decrypted_auth_config.as_deref(),
resolved.transport.key.decrypted_auth_config.as_deref(),
);
let (execution_strategy, conversion_mode) =
ai_local_execution_contract_for_formats(client_api_format, provider_api_format);
Some(LocalOpenAiResponsesCandidatePayloadParts {
auth_header: resolved_headers.auth_header,
auth_value: resolved_headers.auth_value,
auth_header: resolved.headers.auth_header,
auth_value: resolved.headers.auth_value,
mapped_model,
provider_api_format: provider_api_format.to_string(),
provider_request_body,
provider_request_body: resolved.body,
provider_request_headers,
upstream_url,
upstream_url: resolved.upstream_url,
execution_strategy,
conversion_mode,
is_antigravity: false,
envelope_name: Some(GEMINI_CLI_V1INTERNAL_ENVELOPE_NAME),
upstream_is_stream,
transport: resolved_transport,
transport: resolved.transport,
transport_profile: None,
image_request_summary: None,
})