aix-rs 1.0.0

Manage AI gateway profiles and launch AI coding tools with the right credentials
use axum::body::Body;
use axum::http::header::CONNECTION;
use axum::http::{HeaderName, Response};
use futures_util::StreamExt;
use std::collections::HashSet;

pub(crate) enum ResponseStreamEnd {
    Complete,
    Error,
}

pub(crate) trait ResponseBodyObserver: Send + 'static {
    fn observe(&mut self, bytes: &[u8]);
    fn finish(&mut self, stream_end: ResponseStreamEnd);
}

pub(crate) fn forward_response(
    upstream: reqwest::Response,
    forwarded_headers: &'static [&'static str],
) -> Result<Response<Body>, axum::http::Error> {
    let status = upstream.status();
    let headers = upstream.headers().clone();
    let stream = upstream
        .bytes_stream()
        .map(|chunk| chunk.map_err(std::io::Error::other));
    let mut response = Response::builder().status(status);
    for header in forwarded_headers {
        let name = HeaderName::from_static(header);
        if let Some(value) = headers.get(&name) {
            response = response.header(name, value);
        }
    }
    response.body(Body::from_stream(stream))
}

pub(crate) fn forward_response_observed(
    upstream: reqwest::Response,
    forwarded_headers: &'static [&'static str],
    observer: Box<dyn ResponseBodyObserver>,
) -> Result<Response<Body>, axum::http::Error> {
    let status = upstream.status();
    let headers = upstream.headers().clone();
    let upstream = Box::pin(upstream.bytes_stream());
    let stream = futures_util::stream::unfold(
        (Some(upstream), Some(observer)),
        |(mut upstream, mut observer)| async move {
            let upstream_stream = upstream.as_mut()?;
            match upstream_stream.next().await {
                Some(Ok(chunk)) => {
                    if let Some(observer) = observer.as_mut() {
                        observer.observe(&chunk);
                    }
                    Some((Ok::<_, std::io::Error>(chunk), (upstream, observer)))
                }
                Some(Err(error)) => {
                    if let Some(mut observer) = observer.take() {
                        observer.finish(ResponseStreamEnd::Error);
                    }
                    Some((Err(std::io::Error::other(error)), (None, None)))
                }
                None => {
                    if let Some(mut observer) = observer.take() {
                        observer.finish(ResponseStreamEnd::Complete);
                    }
                    None
                }
            }
        },
    );
    let mut response = Response::builder().status(status);
    for header in forwarded_headers {
        let name = HeaderName::from_static(header);
        if let Some(value) = headers.get(&name) {
            response = response.header(name, value);
        }
    }
    response.body(Body::from_stream(stream))
}

pub(crate) fn forward_response_passthrough_observed(
    upstream: reqwest::Response,
    observer: Box<dyn ResponseBodyObserver>,
) -> Result<Response<Body>, axum::http::Error> {
    let status = upstream.status();
    let headers = upstream.headers().clone();
    let connection_headers = connection_header_names(&headers);
    let upstream = Box::pin(upstream.bytes_stream());
    let stream = futures_util::stream::unfold(
        (Some(upstream), Some(observer)),
        |(mut upstream, mut observer)| async move {
            let upstream_stream = upstream.as_mut()?;
            match upstream_stream.next().await {
                Some(Ok(chunk)) => {
                    if let Some(observer) = observer.as_mut() {
                        observer.observe(&chunk);
                    }
                    Some((Ok::<_, std::io::Error>(chunk), (upstream, observer)))
                }
                Some(Err(error)) => {
                    if let Some(mut observer) = observer.take() {
                        observer.finish(ResponseStreamEnd::Error);
                    }
                    Some((Err(std::io::Error::other(error)), (None, None)))
                }
                None => {
                    if let Some(mut observer) = observer.take() {
                        observer.finish(ResponseStreamEnd::Complete);
                    }
                    None
                }
            }
        },
    );
    let mut response = Response::builder().status(status);
    for (name, value) in &headers {
        if should_forward_header(name.as_str(), &connection_headers) {
            response = response.header(name, value);
        }
    }
    response.body(Body::from_stream(stream))
}

fn connection_header_names(headers: &reqwest::header::HeaderMap) -> HashSet<String> {
    headers
        .get_all(CONNECTION)
        .iter()
        .filter_map(|value| value.to_str().ok())
        .flat_map(|value| value.split(','))
        .map(|name| name.trim().to_ascii_lowercase())
        .filter(|name| !name.is_empty())
        .collect()
}

fn should_forward_header(name: &str, connection_headers: &HashSet<String>) -> bool {
    !matches!(
        name.to_ascii_lowercase().as_str(),
        "connection"
            | "content-length"
            | "keep-alive"
            | "proxy-authenticate"
            | "proxy-authorization"
            | "te"
            | "trailer"
            | "transfer-encoding"
            | "upgrade"
    ) && !connection_headers.contains(&name.to_ascii_lowercase())
}