refactor ai serving modules and crates

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

@@ -0,0 +1,21 @@
+pub(crate) mod private_envelope;
+
+pub(crate) mod kiro {
+    pub(crate) use crate::ai_serving::pure::KiroToClaudeCliStreamState;
+}
+
+pub(crate) use crate::ai_serving::{
+    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, ANTIGRAVITY_V1INTERNAL_ENVELOPE_NAME,
+    GEMINI_CLI_V1INTERNAL_ENVELOPE_NAME,
+};
+pub(crate) use kiro::KiroToClaudeCliStreamState;
+pub(crate) use private_envelope::{
+    maybe_build_provider_private_stream_normalizer,
+    maybe_normalize_provider_private_sync_report_payload,
+    normalize_provider_private_report_context, normalize_provider_private_response_value,
+    provider_private_response_allows_sync_finalize, transform_provider_private_stream_line,
+    ProviderPrivateStreamNormalizer,
+};

apps/aether-gateway/src/ai_serving/adaptation/private_envelope.rs

@@ -0,0 +1,10 @@
+#[path = "private_envelope/sync.rs"]
+mod sync;
+
+pub(crate) use self::sync::maybe_normalize_provider_private_sync_report_payload;
+pub(crate) use crate::ai_serving::{
+    maybe_build_provider_private_stream_normalizer, normalize_provider_private_report_context,
+    normalize_provider_private_response_value, provider_private_response_allows_sync_finalize,
+    stream_body_contains_error_event, transform_provider_private_stream_line,
+    ProviderPrivateStreamNormalizer,
+};

apps/aether-gateway/src/ai_serving/adaptation/private_envelope/sync.rs

@@ -0,0 +1,70 @@
+use base64::Engine as _;
+use serde_json::Value;
+
+use crate::{usage::GatewaySyncReportRequest, GatewayError};
+
+use super::{
+    maybe_build_provider_private_stream_normalizer, normalize_provider_private_report_context,
+    normalize_provider_private_response_value, provider_private_response_allows_sync_finalize,
+    stream_body_contains_error_event, ProviderPrivateStreamNormalizer,
+};
+
+pub(crate) fn maybe_normalize_provider_private_sync_report_payload(
+    payload: &GatewaySyncReportRequest,
+) -> Result<Option<GatewaySyncReportRequest>, GatewayError> {
+    let Some(report_context) = payload.report_context.as_ref() else {
+        return Ok(Some(payload.clone()));
+    };
+    if !report_context
+        .get("has_envelope")
+        .and_then(Value::as_bool)
+        .unwrap_or(false)
+    {
+        return Ok(Some(payload.clone()));
+    }
+    if !provider_private_response_allows_sync_finalize(report_context) {
+        return Ok(None);
+    }
+
+    let mut normalized = payload.clone();
+    normalized.report_context = normalize_provider_private_report_context(Some(report_context));
+
+    if let Some(body_json) = payload.body_json.clone() {
+        normalized.body_json = normalize_provider_private_response_value(body_json, report_context);
+        if normalized.body_json.is_none() {
+            return Ok(None);
+        }
+    }
+
+    if let Some(body_base64) = payload.body_base64.as_deref() {
+        let body_bytes = base64::engine::general_purpose::STANDARD
+            .decode(body_base64)
+            .map_err(|err| GatewayError::Internal(err.to_string()))?;
+        let Some(normalized_bytes) =
+            normalize_provider_private_stream_bytes(report_context, &body_bytes)?
+        else {
+            return Ok(None);
+        };
+        if stream_body_contains_error_event(&normalized_bytes) {
+            return Ok(None);
+        }
+        normalized.body_base64 = (!normalized_bytes.is_empty())
+            .then(|| base64::engine::general_purpose::STANDARD.encode(normalized_bytes));
+    }
+
+    Ok(Some(normalized))
+}
+
+fn normalize_provider_private_stream_bytes(
+    report_context: &Value,
+    body: &[u8],
+) -> Result<Option<Vec<u8>>, GatewayError> {
+    let Some(mut normalizer): Option<ProviderPrivateStreamNormalizer<'_>> =
+        maybe_build_provider_private_stream_normalizer(Some(report_context))
+    else {
+        return Ok(Some(body.to_vec()));
+    };
+    let mut normalized = normalizer.push_chunk(body).map_err(GatewayError::from)?;
+    normalized.extend(normalizer.finish().map_err(GatewayError::from)?);
+    Ok(Some(normalized))
+}