Skip to content

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.

11.2 KB
Raw Blame
use std::fmt;
use std::io::Read;
use std::mem::size_of;

use hiroute_gateway_core::runtime::attempt::{AttemptError, AttemptRequestBodyReader};
use hiroute_gateway_core::runtime::body::{
    ChargedBytes, ChargedBytesBuilder, MemoryRole, Reservation, StreamBudget,
};

use crate::replay::{ReplayReader, ReplayStore};

use super::template::{PreparedNativeTemplate, PreparedReplayTemplate, ReplacementEncoding};

pub fn sequential_attempt_body(
    template: PreparedNativeTemplate,
    replay: ReplayStore,
    budget: &StreamBudget,
    write_quantum: usize,
) -> Result<Box<dyn AttemptRequestBodyReader>, AttemptError> {
    let retained_bytes = template.retained_bytes();
    let template = PreparedReplayTemplate {
        bytes: template.bytes,
        replacements: template.replacements,
        wire_len: template.wire_len,
    };
    sequential_replay_body_with_retained_bytes(
        template,
        replay,
        budget,
        write_quantum,
        retained_bytes,
    )
}

pub(crate) fn sequential_replay_body(
    template: PreparedReplayTemplate,
    replay: ReplayStore,
    budget: &StreamBudget,
    write_quantum: usize,
) -> Result<Box<dyn AttemptRequestBodyReader>, AttemptError> {
    let retained_bytes = template.retained_bytes();
    sequential_replay_body_with_retained_bytes(
        template,
        replay,
        budget,
        write_quantum,
        retained_bytes,
    )
}

fn sequential_replay_body_with_retained_bytes(
    template: PreparedReplayTemplate,
    replay: ReplayStore,
    budget: &StreamBudget,
    write_quantum: usize,
    retained_bytes: Option<usize>,
) -> Result<Box<dyn AttemptRequestBodyReader>, AttemptError> {
    if write_quantum == 0 {
        return Err(AttemptError::ZeroWriteQuantum);
    }
    if !replay.is_prevalidated() {
        return Err(AttemptError::Transport(
            "attempt replay was not prevalidated".into(),
        ));
    }
    let content_buffer_bytes = write_quantum.min(8 * 1024);
    let metadata_bytes = retained_bytes
        .and_then(|bytes| bytes.checked_add(content_buffer_bytes))
        .and_then(|bytes| bytes.checked_add(size_of::<SequentialNativeBody>()))
        .ok_or_else(|| AttemptError::Transport("wire template overflow".into()))?;
    let metadata = budget.reserve(MemoryRole::AttemptWire, metadata_bytes)?;
    Ok(Box::new(SequentialNativeBody {
        template,
        replay: Some(replay),
        budget: budget.clone(),
        write_quantum,
        metadata: Some(metadata),
        template_offset: 0,
        replacement_index: 0,
        content_reader: None,
        content_buffer: vec![0_u8; content_buffer_bytes],
        content_offset: 0,
        content_len: 0,
        escape: [0_u8; 6],
        escape_offset: 0,
        escape_len: 0,
        emitted: 0,
        verified_complete: false,
        released: false,
    }))
}

struct SequentialNativeBody {
    template: PreparedReplayTemplate,
    replay: Option<ReplayStore>,
    budget: StreamBudget,
    write_quantum: usize,
    metadata: Option<Reservation>,
    template_offset: usize,
    replacement_index: usize,
    content_reader: Option<ReplayReader>,
    content_buffer: Vec<u8>,
    content_offset: usize,
    content_len: usize,
    escape: [u8; 6],
    escape_offset: usize,
    escape_len: usize,
    emitted: usize,
    verified_complete: bool,
    released: bool,
}

impl fmt::Debug for SequentialNativeBody {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter
            .debug_struct("SequentialNativeBody")
            .field("wire_len", &self.template.wire_len)
            .field("write_quantum", &self.write_quantum)
            .field("emitted", &self.emitted)
            .field("released", &self.released)
            .finish()
    }
}

impl AttemptRequestBodyReader for SequentialNativeBody {
    fn visible_bytes(&self) -> usize {
        self.template.wire_len
    }

    fn max_chunk_bytes(&self) -> usize {
        self.write_quantum
    }

    fn next_chunk(&mut self) -> Result<Option<ChargedBytes>, AttemptError> {
        if self.released {
            return Ok(None);
        }
        if self.emitted == self.template.wire_len {
            self.verify_complete()?;
            return Ok(None);
        }
        let capacity = self
            .write_quantum
            .min(self.template.wire_len.saturating_sub(self.emitted));
        let mut output = ChargedBytesBuilder::new(&self.budget, MemoryRole::AttemptWire, capacity)?;
        while self.emitted < self.template.wire_len && output.len() < capacity {
            if self.escape_offset < self.escape_len {
                output.push(self.escape[self.escape_offset])?;
                self.escape_offset += 1;
                self.emitted += 1;
                continue;
            }
            if self.content_reader.is_some() {
                match self.next_content_byte()? {
                    Some(byte) => {
                        let encoding = self
                            .template
                            .replacements
                            .get(self.replacement_index)
                            .ok_or_else(|| {
                                AttemptError::Transport("missing template replacement".into())
                            })?
                            .encoding;
                        self.prepare_output(byte, encoding);
                        continue;
                    }
                    None => {
                        self.content_reader.take();
                        let replacement = &self.template.replacements[self.replacement_index];
                        self.template_offset = replacement.end;
                        self.replacement_index += 1;
                        continue;
                    }
                }
            }
            let next_start = self
                .template
                .replacements
                .get(self.replacement_index)
                .map_or(self.template.bytes.len(), |replacement| replacement.start);
            if self.template_offset < next_start {
                let remaining_capacity = capacity - output.len();
                let end = next_start.min(self.template_offset + remaining_capacity);
                output.extend_from_slice(&self.template.bytes[self.template_offset..end])?;
                let written = end - self.template_offset;
                self.template_offset = end;
                self.emitted += written;
                continue;
            }
            if let Some(replacement) = self.template.replacements.get(self.replacement_index) {
                let replay = self
                    .replay
                    .as_ref()
                    .ok_or_else(|| AttemptError::Transport("replay owner released".into()))?;
                self.content_reader = Some(
                    replay
                        .reader(&replacement.content)
                        .map_err(replay_attempt_error)?,
                );
                self.content_offset = 0;
                self.content_len = 0;
                continue;
            }
            if self.template_offset != self.template.bytes.len() {
                return Err(AttemptError::Transport(
                    "wire template cursor is inconsistent".into(),
                ));
            }
            break;
        }
        if output.is_empty() {
            return Err(AttemptError::Transport(
                "sequential encoder ended before declared length".into(),
            ));
        }
        Ok(Some(output.finish()))
    }

    fn release(&mut self) {
        if self.released {
            return;
        }
        self.content_reader.take();
        self.replay.take();
        self.content_buffer.clear();
        self.content_buffer.shrink_to_fit();
        self.template.release_storage();
        self.metadata.take();
        self.released = true;
    }
}

impl SequentialNativeBody {
    fn verify_complete(&mut self) -> Result<(), AttemptError> {
        if self.verified_complete {
            return Ok(());
        }
        if self.escape_offset != self.escape_len || self.content_offset != self.content_len {
            return Err(AttemptError::Transport(
                "sequential encoder exceeded its declared length".into(),
            ));
        }
        if let Some(reader) = self.content_reader.as_mut() {
            reader.verify_terminal().map_err(replay_attempt_error)?;
            self.content_reader.take();
            let replacement = self
                .template
                .replacements
                .get(self.replacement_index)
                .ok_or_else(|| AttemptError::Transport("missing template replacement".into()))?;
            self.template_offset = replacement.end;
            self.replacement_index += 1;
        }
        if self.replacement_index != self.template.replacements.len()
            || self.template_offset != self.template.bytes.len()
        {
            return Err(AttemptError::Transport(
                "sequential encoder ended before template verification".into(),
            ));
        }
        self.verified_complete = true;
        Ok(())
    }

    fn next_content_byte(&mut self) -> Result<Option<u8>, AttemptError> {
        if self.content_offset == self.content_len {
            let reader = self
                .content_reader
                .as_mut()
                .ok_or_else(|| AttemptError::Transport("missing ContentRef reader".into()))?;
            self.content_len = reader
                .read(&mut self.content_buffer)
                .map_err(|_| AttemptError::SequentialBodyContractViolation)?;
            self.content_offset = 0;
            if self.content_len == 0 {
                return Ok(None);
            }
        }
        let byte = self.content_buffer[self.content_offset];
        self.content_offset += 1;
        Ok(Some(byte))
    }

    fn prepare_output(&mut self, byte: u8, encoding: ReplacementEncoding) {
        self.escape_offset = 0;
        if encoding == ReplacementEncoding::RawJson {
            self.escape[0] = byte;
            self.escape_len = 1;
            return;
        }
        let escape_len = match byte {
            b'"' => {
                self.escape[..2].copy_from_slice(br#"\""#);
                2
            }
            b'\\' => {
                self.escape[..2].copy_from_slice(br#"\\"#);
                2
            }
            b'\x08' => self.short_escape(b'b'),
            b'\x0c' => self.short_escape(b'f'),
            b'\n' => self.short_escape(b'n'),
            b'\r' => self.short_escape(b'r'),
            b'\t' => self.short_escape(b't'),
            0x00..=0x1f => {
                const HEX: &[u8; 16] = b"0123456789abcdef";
                self.escape[..4].copy_from_slice(b"\\u00");
                self.escape[4] = HEX[(byte >> 4) as usize];
                self.escape[5] = HEX[(byte & 0x0f) as usize];
                6
            }
            _ => {
                self.escape[0] = byte;
                1
            }
        };
        self.escape_len = escape_len;
    }

    fn short_escape(&mut self, value: u8) -> usize {
        self.escape[0] = b'\\';
        self.escape[1] = value;
        2
    }
}

impl Drop for SequentialNativeBody {
    fn drop(&mut self) {
        self.release();
    }
}

fn replay_attempt_error(_error: crate::replay::ReplayError) -> AttemptError {
    AttemptError::SequentialBodyContractViolation
}