feat(tunnel): 请求体流式传输 & OpenAI CLI 请求 key 排序优化

Hub 端:
- open_local_stream 不再接收 body 参数，改为通过 push_local_request_body 分块推送
- 请求体按 32KB 分帧发送，避免大请求一次性压缩和传输
- local_relay 改为流式解析 envelope 和转发请求体

Proxy 端:
- stream_handler 改为流式传输请求体到上游，不再预先收集完整 body
- upstream_client 请求体类型从 Full<Bytes> 改为 UnsyncBoxBody 以支持流式传输
- dispatcher 将 StreamEnd/StreamError 事件转发给 stream handler

Python 端:
- hub_transport relay envelope 改为异步生成器流式发送
- 提取 reorder_openai_cli_request_prefix_keys 为公共函数
- Codex passthrough 路径也应用稳定的前缀 key 排序

aether-hub/Cargo.lock

@@ -10,7 +10,7 @@ checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
 [[package]]
 name = "aether-hub"
-version = "0.1.8"
+version = "0.1.9"
 dependencies = [
  "async-stream",
  "axum",
@@ -19,6 +19,7 @@ dependencies = [
  "dashmap",
  "flate2",
  "futures-util",
+ "http-body-util",
  "parking_lot",
  "reqwest",
  "serde",

aether-hub/Cargo.toml

@@ -18,6 +18,7 @@ flate2 = "1"
 futures-util = "0.3"
 bytes = "1"
 async-stream = "0.3"
+http-body-util = "0.1"
 reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls"] }
 
 [profile.release]

aether-hub/src/hub.rs

@@ -15,6 +15,8 @@ use tracing::{debug, info, warn};
 use crate::control_plane::ControlPlaneClient;
 use crate::protocol;
 
+const MAX_REQUEST_BODY_FRAME_SIZE: usize = 32 * 1024;
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum SendStatus {
     Queued,
@@ -421,7 +423,6 @@ impl HubRouter {
         &self,
         node_id: &str,
         meta: &protocol::RequestMeta,
-        body: Bytes,
     ) -> Result<Arc<LocalStream>, String> {
         let proxy_conn = self
             .get_proxy_conn(node_id)
@@ -454,20 +455,6 @@ impl HubRouter {
             &meta_payload,
         );
 
-        let (body_payload, body_flags) = match protocol::compress_payload(body.as_ref()) {
-            Ok(result) => result,
-            Err(e) => {
-                proxy_conn.release_stream();
-                return Err(format!("failed to compress request body: {e}"));
-            }
-        };
-        let body_frame = protocol::encode_frame(
-            proxy_stream_id,
-            protocol::REQUEST_BODY,
-            body_flags | protocol::FLAG_END_STREAM,
-            &body_payload,
-        );
-
         // Frames encoded successfully -- now register the stream.
         let local_stream_id = self.next_local_stream_id.fetch_add(1, Ordering::Relaxed);
         let local_stream = Arc::new(LocalStream::new(
@@ -481,18 +468,75 @@ impl HubRouter {
             .insert((proxy_conn.id, proxy_stream_id), local_stream_id);
 
         match proxy_conn.send(Message::Binary(header_frame.into())) {
-            SendStatus::Queued => {}
+            SendStatus::Queued => Ok(local_stream),
             SendStatus::Closed | SendStatus::Congested => {
                 self.cleanup_local_stream(local_stream_id);
                 proxy_conn.release_stream();
-                return Err("proxy connection congested".to_string());
+                Err("proxy connection congested".to_string())
+            }
+        }
+    }
+
+    pub fn push_local_request_body(
+        &self,
+        local_stream_id: u64,
+        payload: Bytes,
+        end_stream: bool,
+    ) -> Result<(), String> {
+        let stream = self
+            .local_streams
+            .get(&local_stream_id)
+            .map(|entry| entry.value().clone())
+            .ok_or_else(|| "local stream not found".to_string())?;
+        let proxy_conn = self
+            .proxy_conns_by_id
+            .get(&stream.proxy_conn_id)
+            .map(|entry| entry.value().clone())
+            .ok_or_else(|| "proxy connection unavailable".to_string())?;
+
+        let total_chunks = payload.len().div_ceil(MAX_REQUEST_BODY_FRAME_SIZE);
+        if total_chunks == 0 {
+            if end_stream {
+                self.send_request_body_frame(&proxy_conn, stream.proxy_stream_id, &[], true)?;
+            }
+        } else {
+            for (index, chunk) in payload.chunks(MAX_REQUEST_BODY_FRAME_SIZE).enumerate() {
+                let is_last_chunk = index + 1 == total_chunks;
+                self.send_request_body_frame(
+                    &proxy_conn,
+                    stream.proxy_stream_id,
+                    chunk,
+                    end_stream && is_last_chunk,
+                )?;
             }
         }
 
+        Ok(())
+    }
+
+    fn send_request_body_frame(
+        &self,
+        proxy_conn: &Arc<ProxyConn>,
+        proxy_stream_id: u32,
+        payload: &[u8],
+        end_stream: bool,
+    ) -> Result<(), String> {
+        let (body_payload, body_flags) = protocol::compress_payload(payload)
+            .map_err(|e| format!("failed to compress request body: {e}"))?;
+        let body_frame = protocol::encode_frame(
+            proxy_stream_id,
+            protocol::REQUEST_BODY,
+            body_flags
+                | if end_stream {
+                    protocol::FLAG_END_STREAM
+                } else {
+                    0
+                },
+            &body_payload,
+        );
         match proxy_conn.send(Message::Binary(body_frame.into())) {
-            SendStatus::Queued => Ok(local_stream),
+            SendStatus::Queued => Ok(()),
             SendStatus::Closed | SendStatus::Congested => {
-                self.cancel_local_stream(local_stream_id, "proxy connection congested");
                 Err("proxy connection congested".to_string())
             }
         }
@@ -772,9 +816,11 @@ mod tests {
         hub.register_proxy(proxy);
 
         let stream = hub
-            .open_local_stream("node-1", &build_meta(), Bytes::new())
+            .open_local_stream("node-1", &build_meta())
             .expect("open local stream");
         let _ = proxy_rx.try_recv().expect("headers frame");
+        hub.push_local_request_body(stream.id, Bytes::new(), true)
+            .expect("finish empty body");
         let _ = proxy_rx.try_recv().expect("body frame");
 
         hub.cancel_local_stream(stream.id, "client dropped");
@@ -787,4 +833,46 @@ mod tests {
         let header = protocol::FrameHeader::parse(&cancelled_data).expect("cancel frame header");
         assert_eq!(header.msg_type, protocol::STREAM_ERROR);
     }
+
+    #[tokio::test]
+    async fn push_local_request_body_splits_large_payload_and_marks_end() {
+        let hub = HubRouter::new(ControlPlaneClient::disabled());
+
+        let (proxy_tx, mut proxy_rx) = mpsc::channel(8);
+        let (proxy_close_tx, _) = watch::channel(false);
+        let proxy = Arc::new(ProxyConn::new(
+            200,
+            "node-2".to_string(),
+            "Node 2".to_string(),
+            proxy_tx,
+            proxy_close_tx,
+            16,
+        ));
+        hub.register_proxy(proxy);
+
+        let stream = hub
+            .open_local_stream("node-2", &build_meta())
+            .expect("open local stream");
+        let _ = proxy_rx.try_recv().expect("headers frame");
+
+        let payload = Bytes::from(vec![b'x'; MAX_REQUEST_BODY_FRAME_SIZE + 17]);
+        hub.push_local_request_body(stream.id, payload, true)
+            .expect("push request body");
+
+        let first = match proxy_rx.try_recv().expect("first body frame") {
+            Message::Binary(data) => data.to_vec(),
+            other => panic!("unexpected message: {other:?}"),
+        };
+        let first_header = protocol::FrameHeader::parse(&first).expect("first body header");
+        assert_eq!(first_header.msg_type, protocol::REQUEST_BODY);
+        assert_eq!(first_header.flags & protocol::FLAG_END_STREAM, 0);
+
+        let second = match proxy_rx.try_recv().expect("second body frame") {
+            Message::Binary(data) => data.to_vec(),
+            other => panic!("unexpected message: {other:?}"),
+        };
+        let second_header = protocol::FrameHeader::parse(&second).expect("second body header");
+        assert_eq!(second_header.msg_type, protocol::REQUEST_BODY);
+        assert_ne!(second_header.flags & protocol::FLAG_END_STREAM, 0);
+    }
 }

aether-hub/src/local_relay.rs

@@ -4,16 +4,19 @@ use std::time::Duration;
 
 use async_stream::stream;
 use axum::body::{Body, Bytes};
-use axum::extract::{ConnectInfo, Path, State};
+use axum::extract::{ConnectInfo, Path, Request, State};
 use axum::http::{HeaderMap, HeaderName, HeaderValue, Response, StatusCode};
 use axum::response::IntoResponse;
+use bytes::BytesMut;
+use futures_util::StreamExt;
 use tracing::warn;
 
-use crate::hub::LocalBodyEvent;
+use crate::hub::{LocalBodyEvent, LocalStream};
 use crate::protocol;
 use crate::AppState;
 
 pub const TUNNEL_ERROR_HEADER: &str = "x-aether-tunnel-error";
+const MAX_RELAY_META_LEN: usize = 256 * 1024;
 
 struct StreamGuard {
     hub: std::sync::Arc<crate::hub::HubRouter>,
@@ -34,7 +37,7 @@ pub async fn relay_request(
     Path(node_id): Path<String>,
     State(state): State<AppState>,
     ConnectInfo(addr): ConnectInfo<SocketAddr>,
-    body: Bytes,
+    request: Request,
 ) -> impl IntoResponse {
     if !addr.ip().is_loopback() {
         return tunnel_error_response(
@@ -44,19 +47,104 @@ pub async fn relay_request(
         );
     }
 
-    let (meta, request_body) = match decode_envelope(body) {
-        Ok(value) => value,
-        Err(error) => {
-            return tunnel_error_response(StatusCode::BAD_REQUEST, "bad_request", &error);
+    let mut body_stream = request.into_body().into_data_stream();
+    let mut envelope_buf = BytesMut::new();
+    let mut meta: Option<protocol::RequestMeta> = None;
+    let mut stream: Option<std::sync::Arc<LocalStream>> = None;
+
+    while let Some(chunk_result) = body_stream.next().await {
+        let chunk = match chunk_result {
+            Ok(chunk) => chunk,
+            Err(error) => {
+                if let Some(active_stream) = &stream {
+                    state
+                        .hub
+                        .cancel_local_stream(active_stream.id, "failed to read relay request body");
+                }
+                warn!(error = %error, "failed to read local relay request body");
+                return tunnel_error_response(
+                    StatusCode::BAD_GATEWAY,
+                    "relay",
+                    "failed to read relay request body",
+                );
+            }
+        };
+
+        if stream.is_none() {
+            envelope_buf.extend_from_slice(&chunk);
+            let Some((parsed_meta, body_offset)) = (match try_decode_envelope_meta(&envelope_buf) {
+                Ok(result) => result,
+                Err(error) => {
+                    return tunnel_error_response(StatusCode::BAD_REQUEST, "bad_request", &error);
+                }
+            }) else {
+                continue;
+            };
+
+            let opened_stream = match state.hub.open_local_stream(&node_id, &parsed_meta) {
+                Ok(stream) => stream,
+                Err(error) => {
+                    return tunnel_error_response(
+                        StatusCode::SERVICE_UNAVAILABLE,
+                        "connect",
+                        &error,
+                    );
+                }
+            };
+
+            if envelope_buf.len() > body_offset {
+                let first_body_chunk = Bytes::copy_from_slice(&envelope_buf[body_offset..]);
+                if let Err(error) =
+                    state
+                        .hub
+                        .push_local_request_body(opened_stream.id, first_body_chunk, false)
+                {
+                    state.hub.cancel_local_stream(opened_stream.id, &error);
+                    return tunnel_error_response(
+                        StatusCode::SERVICE_UNAVAILABLE,
+                        "connect",
+                        &error,
+                    );
+                }
+            }
+
+            envelope_buf.clear();
+            meta = Some(parsed_meta);
+            stream = Some(opened_stream);
+            continue;
+        }
+
+        let Some(active_stream) = &stream else {
+            continue;
+        };
+        if let Err(error) = state
+            .hub
+            .push_local_request_body(active_stream.id, chunk, false)
+        {
+            state.hub.cancel_local_stream(active_stream.id, &error);
+            return tunnel_error_response(StatusCode::SERVICE_UNAVAILABLE, "connect", &error);
+        }
+    }
+
+    let (meta, stream) = match (meta, stream) {
+        (Some(meta), Some(stream)) => (meta, stream),
+        _ => {
+            return tunnel_error_response(
+                StatusCode::BAD_REQUEST,
+                "bad_request",
+                "relay envelope metadata truncated",
+            );
         }
     };
 
-    let stream = match state.hub.open_local_stream(&node_id, &meta, request_body) {
-        Ok(stream) => stream,
-        Err(error) => {
-            return tunnel_error_response(StatusCode::SERVICE_UNAVAILABLE, "connect", &error);
-        }
-    };
+    if let Err(error) = state
+        .hub
+        .push_local_request_body(stream.id, Bytes::new(), true)
+    {
+        state.hub.cancel_local_stream(stream.id, &error);
+        return tunnel_error_response(StatusCode::SERVICE_UNAVAILABLE, "connect", &error);
+    }
+
     let request_guard = StreamGuard {
         hub: state.hub.clone(),
         stream_id: stream.id,
@@ -123,20 +211,25 @@ pub async fn relay_request(
     }
 }
 
-fn decode_envelope(body: Bytes) -> Result<(protocol::RequestMeta, Bytes), String> {
-    if body.len() < 4 {
-        return Err("relay envelope too short".to_string());
+fn try_decode_envelope_meta(
+    buffer: &BytesMut,
+) -> Result<Option<(protocol::RequestMeta, usize)>, String> {
+    if buffer.len() < 4 {
+        return Ok(None);
+    }
+    let meta_len = u32::from_be_bytes([buffer[0], buffer[1], buffer[2], buffer[3]]) as usize;
+    if meta_len > MAX_RELAY_META_LEN {
+        return Err("relay metadata too large".to_string());
     }
-    let meta_len = u32::from_be_bytes([body[0], body[1], body[2], body[3]]) as usize;
     let meta_end = 4usize
         .checked_add(meta_len)
         .ok_or_else(|| "relay envelope length overflow".to_string())?;
-    if body.len() < meta_end {
-        return Err("relay envelope metadata truncated".to_string());
+    if buffer.len() < meta_end {
+        return Ok(None);
     }
-    let meta = serde_json::from_slice::<protocol::RequestMeta>(&body[4..meta_end])
+    let meta = serde_json::from_slice::<protocol::RequestMeta>(&buffer[4..meta_end])
         .map_err(|e| format!("invalid relay metadata: {e}"))?;
-    Ok((meta, body.slice(meta_end..)))
+    Ok(Some((meta, meta_end)))
 }
 
 fn append_headers(target: &mut HeaderMap, headers: &[(String, String)]) {