Make Codex and Claude Code subscriptions go further: a local model router that gives routine agent work to economical models and keeps your strongest model for the hard parts.
Rust ai-agentsai-gatewayclaude-codecodexcoding-agentcost-optimizationdeepseekllm-gatewayllm-routerlocal-firstmodel-routingrusttask-routingtauri
use std::collections::BTreeMap;
use std::net::SocketAddr;
use std::time::Duration;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use tokio::time::timeout;
const MAX_HTTP_BYTES: usize = 8 * 1024 * 1024;
#[derive(Clone, Debug)]
pub(crate) struct HttpResponse {
pub status: u16,
pub headers: BTreeMap<String, String>,
pub body: Vec<u8>,
}
impl HttpResponse {
pub fn header(&self, name: &str) -> Option<&str> {
self.headers
.get(&name.to_ascii_lowercase())
.map(String::as_str)
}
}
#[derive(Debug, thiserror::Error)]
pub(crate) enum HttpError {
#[error("cannot connect to E2E SUT: {0}")]
Connect(std::io::Error),
#[error("E2E HTTP I/O failed: {0}")]
Io(std::io::Error),
#[error("E2E HTTP exchange exceeded its deadline")]
Timeout,
#[error("E2E peer returned malformed HTTP: {0}")]
Malformed(&'static str),
#[error("E2E HTTP response exceeded the bounded capture limit")]
TooLarge,
}
pub(crate) async fn post_json(
addr: SocketAddr,
path: &str,
protocol_headers: &[(&str, &str)],
body: &[u8],
deadline: Duration,
) -> Result<HttpResponse, HttpError> {
timeout(deadline, async {
let mut stream = TcpStream::connect(addr).await.map_err(HttpError::Connect)?;
let mut request = format!(
"POST {path} HTTP/1.1\r\nHost: {addr}\r\nContent-Type: application/json\r\nAccept: text/event-stream\r\nConnection: close\r\nContent-Length: {}\r\n",
body.len()
);
for (name, value) in protocol_headers {
request.push_str(name);
request.push_str(": ");
request.push_str(value);
request.push_str("\r\n");
}
request.push_str("\r\n");
stream
.write_all(request.as_bytes())
.await
.map_err(HttpError::Io)?;
stream.write_all(body).await.map_err(HttpError::Io)?;
stream.flush().await.map_err(HttpError::Io)?;
read_response(&mut stream).await
})
.await
.map_err(|_| HttpError::Timeout)?
}
pub(crate) async fn get(
addr: SocketAddr,
path: &str,
headers: &[(&str, &str)],
deadline: Duration,
) -> Result<HttpResponse, HttpError> {
timeout(deadline, async {
let mut stream = TcpStream::connect(addr).await.map_err(HttpError::Connect)?;
let mut request = format!(
"GET {path} HTTP/1.1\r\nHost: {addr}\r\nAccept: application/json\r\nConnection: close\r\n"
);
for (name, value) in headers {
request.push_str(name);
request.push_str(": ");
request.push_str(value);
request.push_str("\r\n");
}
request.push_str("\r\n");
stream
.write_all(request.as_bytes())
.await
.map_err(HttpError::Io)?;
stream.flush().await.map_err(HttpError::Io)?;
read_response(&mut stream).await
})
.await
.map_err(|_| HttpError::Timeout)?
}
async fn read_response(stream: &mut TcpStream) -> Result<HttpResponse, HttpError> {
let mut wire = Vec::new();
let mut scratch = [0_u8; 16 * 1024];
let mut shape = None;
loop {
let count = stream.read(&mut scratch).await.map_err(HttpError::Io)?;
if count == 0 {
break;
}
wire.extend_from_slice(&scratch[..count]);
if wire.len() > MAX_HTTP_BYTES {
return Err(HttpError::TooLarge);
}
if shape.is_none() {
shape = response_shape(&wire)?;
}
if shape
.as_ref()
.is_some_and(|shape| response_is_complete(&wire, shape))
{
break;
}
}
parse_response(&wire)
}
#[derive(Clone, Debug)]
struct ResponseShape {
body_offset: usize,
content_length: Option<usize>,
chunked: bool,
}
fn response_shape(wire: &[u8]) -> Result<Option<ResponseShape>, HttpError> {
let Some(head_end) = find_bytes(wire, b"\r\n\r\n") else {
return Ok(None);
};
let head = std::str::from_utf8(&wire[..head_end])
.map_err(|_| HttpError::Malformed("non-UTF-8 response head"))?;
let mut content_length = None;
let mut chunked = false;
for line in head.lines().skip(1) {
let Some((name, value)) = line.split_once(':') else {
return Err(HttpError::Malformed("response header has no colon"));
};
if name.eq_ignore_ascii_case("content-length") {
content_length = Some(
value
.trim()
.parse()
.map_err(|_| HttpError::Malformed("invalid content length"))?,
);
}
if name.eq_ignore_ascii_case("transfer-encoding")
&& value.to_ascii_lowercase().contains("chunked")
{
chunked = true;
}
}
Ok(Some(ResponseShape {
body_offset: head_end + 4,
content_length,
chunked,
}))
}
fn response_is_complete(wire: &[u8], shape: &ResponseShape) -> bool {
let body = &wire[shape.body_offset.min(wire.len())..];
if shape.chunked {
decode_chunked(body).is_ok_and(|decoded| decoded.is_some())
} else if let Some(length) = shape.content_length {
body.len() >= length
} else {
false
}
}
fn parse_response(wire: &[u8]) -> Result<HttpResponse, HttpError> {
let shape =
response_shape(wire)?.ok_or(HttpError::Malformed("response ended before its head"))?;
let head_end = shape.body_offset - 4;
let head = std::str::from_utf8(&wire[..head_end])
.map_err(|_| HttpError::Malformed("non-UTF-8 response head"))?;
let mut lines = head.lines();
let status = lines
.next()
.and_then(|line| line.split_whitespace().nth(1))
.ok_or(HttpError::Malformed("missing HTTP status"))?
.parse()
.map_err(|_| HttpError::Malformed("invalid HTTP status"))?;
let mut headers = BTreeMap::new();
for line in lines {
let (name, value) = line
.split_once(':')
.ok_or(HttpError::Malformed("response header has no colon"))?;
headers.insert(name.trim().to_ascii_lowercase(), value.trim().to_owned());
}
let wire_body = &wire[shape.body_offset..];
let body = if shape.chunked {
decode_chunked(wire_body)?.ok_or(HttpError::Malformed("incomplete chunked response"))?
} else if let Some(length) = shape.content_length {
if wire_body.len() < length {
return Err(HttpError::Malformed("truncated response body"));
}
wire_body[..length].to_vec()
} else {
wire_body.to_vec()
};
Ok(HttpResponse {
status,
headers,
body,
})
}
fn decode_chunked(wire: &[u8]) -> Result<Option<Vec<u8>>, HttpError> {
let mut cursor = 0;
let mut decoded = Vec::new();
loop {
let Some(relative_end) = find_bytes(&wire[cursor..], b"\r\n") else {
return Ok(None);
};
let size_end = cursor + relative_end;
let size_text = std::str::from_utf8(&wire[cursor..size_end])
.map_err(|_| HttpError::Malformed("non-UTF-8 chunk size"))?;
let size =
usize::from_str_radix(size_text.split(';').next().unwrap_or_default().trim(), 16)
.map_err(|_| HttpError::Malformed("invalid chunk size"))?;
cursor = size_end + 2;
if size == 0 {
if wire.len() < cursor + 2 {
return Ok(None);
}
return Ok(Some(decoded));
}
if wire.len() < cursor + size + 2 {
return Ok(None);
}
decoded.extend_from_slice(&wire[cursor..cursor + size]);
cursor += size;
if wire.get(cursor..cursor + 2) != Some(b"\r\n") {
return Err(HttpError::Malformed("chunk is missing its terminator"));
}
cursor += 2;
}
}
fn find_bytes(haystack: &[u8], needle: &[u8]) -> Option<usize> {
haystack
.windows(needle.len())
.position(|window| window == needle)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn decodes_a_chunked_sse_response() {
let wire = b"HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nTransfer-Encoding: chunked\r\n\r\n5\r\ndata:\r\n3\r\n x\n\r\n0\r\n\r\n";
let response = parse_response(wire).unwrap();
assert_eq!(response.status, 200);
assert_eq!(response.body, b"data: x\n");
}
}