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::io::Write;
use std::net::SocketAddr;
use std::path::Path;
use serde::Serialize;
pub(super) fn write_ready_frame(role: &hiroute_daemon::RoleAllHandle) -> std::io::Result<()> {
write_ready_to(
&mut std::io::stdout().lock(),
role.control_endpoint().path(),
role.gateway_address(),
)
}
pub(super) fn write_startup_failure_frame(
code: hiroute_diagnostics::event::StartupFailureCode,
) -> std::io::Result<()> {
let mut writer = std::io::stdout().lock();
StartupFailure {
schema: "hiroute.daemon-startup-failure/v1",
code,
}
.write_to(&mut writer)
}
#[derive(Serialize)]
#[serde(deny_unknown_fields)]
struct StartupFailure {
schema: &'static str,
code: hiroute_diagnostics::event::StartupFailureCode,
}
impl StartupFailure {
fn write_to(&self, writer: &mut impl Write) -> std::io::Result<()> {
serde_json::to_writer(&mut *writer, self)?;
writer.write_all(b"\n")?;
writer.flush()
}
}
pub(super) fn write_ready_to(
writer: &mut impl Write,
control_endpoint: &Path,
gateway_listen: SocketAddr,
) -> std::io::Result<()> {
Ready {
schema: "hiroute.daemon-ready/v1",
role: "all",
control_endpoint,
gateway_listen,
process_id: std::process::id(),
}
.write_to(writer)
}
#[derive(Serialize)]
struct Ready<'a> {
schema: &'static str,
role: &'static str,
control_endpoint: &'a Path,
gateway_listen: SocketAddr,
process_id: u32,
}
impl Ready<'_> {
fn write_to(&self, writer: &mut impl Write) -> std::io::Result<()> {
serde_json::to_writer(&mut *writer, self)?;
writer.write_all(b"\n")?;
writer.flush()
}
}
#[cfg(test)]
mod tests {
use std::io::{self, ErrorKind};
use super::*;
fn ready() -> Ready<'static> {
Ready {
schema: "hiroute.daemon-ready/v1",
role: "all",
control_endpoint: Path::new("/runtime/control.sock"),
gateway_listen: "127.0.0.1:4567".parse().unwrap(),
process_id: 123,
}
}
struct Writer {
bytes: Vec<u8>,
limit: usize,
max_write: usize,
interrupted: bool,
fail_flush: bool,
flushes: usize,
}
impl Default for Writer {
fn default() -> Self {
Self {
bytes: Vec::new(),
limit: usize::MAX,
max_write: usize::MAX,
interrupted: false,
fail_flush: false,
flushes: 0,
}
}
}
impl Write for Writer {
fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
if std::mem::take(&mut self.interrupted) {
return Err(ErrorKind::Interrupted.into());
}
if self.bytes.len() == self.limit {
return Err(ErrorKind::BrokenPipe.into());
}
let count = bytes
.len()
.min(self.max_write)
.min(self.limit - self.bytes.len());
self.bytes.extend_from_slice(&bytes[..count]);
Ok(count)
}
fn flush(&mut self) -> io::Result<()> {
self.flushes += 1;
if self.fail_flush {
Err(ErrorKind::BrokenPipe.into())
} else {
Ok(())
}
}
}
#[test]
fn ready_frame_is_one_flushed_protocol_line() {
let mut writer = Writer::default();
ready().write_to(&mut writer).unwrap();
assert_eq!(writer.bytes.last(), Some(&b'\n'));
assert_eq!(
writer.bytes.iter().filter(|&&byte| byte == b'\n').count(),
1
);
assert_eq!(writer.flushes, 1);
let value: serde_json::Value = serde_json::from_slice(&writer.bytes).unwrap();
assert_eq!(
value,
serde_json::json!({
"schema": "hiroute.daemon-ready/v1", "role": "all",
"control_endpoint": "/runtime/control.sock",
"gateway_listen": "127.0.0.1:4567", "process_id": 123
})
);
}
#[test]
fn startup_failure_frame_exposes_only_the_stable_code() {
let mut writer = Writer::default();
StartupFailure {
schema: "hiroute.daemon-startup-failure/v1",
code: hiroute_diagnostics::event::StartupFailureCode::StorageUnavailable,
}
.write_to(&mut writer)
.unwrap();
assert_eq!(writer.flushes, 1);
assert_eq!(writer.bytes.last(), Some(&b'\n'));
assert_eq!(
serde_json::from_slice::<serde_json::Value>(&writer.bytes).unwrap(),
serde_json::json!({
"schema": "hiroute.daemon-startup-failure/v1",
"code": "storage_unavailable"
})
);
}
#[test]
fn ready_frame_retries_short_and_interrupted_writes() {
let mut writer = Writer {
max_write: 2,
interrupted: true,
..Writer::default()
};
ready().write_to(&mut writer).unwrap();
let mut expected = serde_json::to_vec(&ready()).unwrap();
expected.push(b'\n');
assert_eq!(writer.bytes, expected);
assert_eq!(writer.flushes, 1);
}
#[test]
fn ready_frame_returns_json_write_failure() {
let mut writer = Writer {
limit: 12,
..Writer::default()
};
assert!(ready().write_to(&mut writer).is_err());
assert_eq!(writer.bytes.len(), 12);
assert_eq!(writer.flushes, 0);
}
#[test]
fn ready_frame_returns_newline_failure() {
let expected = serde_json::to_vec(&ready()).unwrap();
let mut writer = Writer {
limit: expected.len(),
..Writer::default()
};
assert!(ready().write_to(&mut writer).is_err());
assert_eq!(writer.bytes, expected);
assert_eq!(writer.flushes, 0);
}
#[test]
fn ready_frame_returns_flush_failure() {
let mut writer = Writer {
fail_flush: true,
..Writer::default()
};
assert!(ready().write_to(&mut writer).is_err());
assert_eq!(writer.bytes.last(), Some(&b'\n'));
assert_eq!(writer.flushes, 1);
}
#[test]
fn ready_frame_returns_zero_write_failure() {
let mut writer = Writer {
max_write: 0,
..Writer::default()
};
assert!(ready().write_to(&mut writer).is_err());
assert!(writer.bytes.is_empty());
assert_eq!(writer.flushes, 0);
}
#[cfg(unix)]
#[test]
fn ready_frame_returns_closed_pipe_failure_with_line_buffered_output() {
let (reader, writer) = nix::unistd::pipe().unwrap();
drop(reader);
let mut writer = io::LineWriter::with_capacity(4096, std::fs::File::from(writer));
assert!(ready().write_to(&mut writer).is_err());
}
}