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.

8.5 KB
Raw Blame
use std::sync::Arc;

use async_trait::async_trait;
use bytes::Bytes;
use hiroute_gateway_core::runtime::body::{BudgetTree, StreamBudget};
use hiroute_gateway_core::transport::{
    GatewayRequestHead, GatewayResponseHead, GatewaySession, HttpProtocol, TransportError,
};
use http::{HeaderMap, Method};

use super::*;
use crate::server::core_runtime::profiles::{CandidateProtocolProfile, fixed_reasoning};

#[test]
fn cancelled_accepted_attempt_is_not_reported_as_transport_failure_or_success() {
    assert_eq!(
        classify_request_observation_outcome(true, false, true),
        "cancelled"
    );
    assert_eq!(
        classify_request_observation_outcome(true, false, false),
        "postcommit_transport_failed"
    );
    assert_eq!(
        classify_request_observation_outcome(true, true, true),
        "cancelled"
    );
    assert_eq!(
        classify_request_observation_outcome(false, false, false),
        "failed"
    );
}

struct FailSecondBodyWrite {
    writes: usize,
    accepted: Vec<Bytes>,
}

#[async_trait]
impl GatewaySession for FailSecondBodyWrite {
    fn request_head(&self) -> Result<GatewayRequestHead, TransportError> {
        Ok(request_head())
    }

    async fn read_request_body(&mut self) -> Result<Option<Bytes>, TransportError> {
        Ok(None)
    }

    async fn write_response_head(
        &mut self,
        _head: GatewayResponseHead,
    ) -> Result<(), TransportError> {
        Ok(())
    }

    async fn write_response_body(
        &mut self,
        body: Bytes,
        _end_stream: bool,
    ) -> Result<(), TransportError> {
        self.writes += 1;
        if self.writes == 2 {
            return Err(TransportError::Io("controlled downstream reset".into()));
        }
        self.accepted.push(body);
        Ok(())
    }
}

#[tokio::test]
async fn production_response_sink_keeps_only_the_tool_unit_accepted_before_reset() {
    let first_id = "native-first".to_owned();
    let second_id = "native-second".to_owned();
    let active = adapters::ActiveResponseDelivery::new(IngressProtocol::Responses, budget());
    let profile = CandidateProtocolProfile::exact_portable_path(
        IngressProtocol::Responses,
        IngressProtocol::Responses,
        "native-runtime-test",
        fixed_reasoning("fixed"),
    );
    let tool_frames = adapters::with_active_response_delivery(active.clone(), async {
        let mut frames = Vec::new();
        for id in [&first_id, &second_id] {
            let mut projector = adapters::NativeResponseProjector::new_for_attempt(
                &profile, true, "runtime-test".into(), None, budget(),
            ).unwrap();
            projector.feed(b"data: {\"type\":\"response.created\",\"response\":{\"id\":\"response\",\"model\":\"native-runtime-test\"}}\n\n", false).unwrap();
            let item = serde_json::json!({"type":"response.output_item.added","output_index":0,
                "item":{"type":"function_call","call_id":id,"id":"item","name":"weather","arguments":"","status":"in_progress"}});
            // Native whitespace and escaped IDs must not hide a delivered tool.
            let encoded = serde_json::to_string(&item).unwrap().replace(":", ": ").replace("native-f", "native-\\u0066");
            let units = projector.feed(format!("data: {encoded}\n\n").as_bytes(), false).unwrap();
            assert_eq!(units.len(), 1);
            frames.push(units[0].bytes.clone());
        }
        frames
    }).await;
    let observation = observation::accepted_request_for_runtime_test();
    let budget = budget();
    let mut downstream = FailSecondBodyWrite {
        writes: 0,
        accepted: Vec::new(),
    };
    let mut session = ReplayBodySession {
        inner: &mut downstream,
        request_head: request_head(),
        request_body: None,
        budget,
        response_capture: AcceptedResponseCapture::new(observation.clone()),
        response_started: true,
        runtime_state_authority: Default::default(),
        continuation_scanner: active.scanner(),
    };

    session
        .write_response_body(Bytes::from(tool_frames[0].clone()), false)
        .await
        .unwrap();
    assert!(observation.has_accepted_attempt());
    assert_eq!(
        observation::accepted_frame_count_for_runtime_test(&observation),
        1
    );

    let error = session
        .write_response_body(Bytes::from(tool_frames[1].clone()), true)
        .await
        .unwrap_err();
    assert!(matches!(error, TransportError::Io(_)));
    assert_eq!(
        observation::accepted_frame_count_for_runtime_test(&observation),
        1
    );
    drop(session);
    assert_eq!(active.accepted_count(), 1);
    assert_eq!(downstream.accepted.len(), 1);
}

#[tokio::test]
async fn native_reasoning_history_is_data_even_without_prior_delivery() {
    let active = adapters::ActiveResponseDelivery::new(IngressProtocol::Responses, budget());
    let profile = CandidateProtocolProfile::exact_portable_path(
        IngressProtocol::Responses,
        IngressProtocol::Responses,
        "native-state-test",
        fixed_reasoning("fixed"),
    );
    let frames = adapters::with_active_response_delivery(active.clone(), async {
        let mut projector = adapters::NativeResponseProjector::new_for_attempt(
            &profile,
            true,
            "state-test".into(),
            None,
            budget(),
        )
        .unwrap();
        let mut frames = Vec::new();
        for (index, state) in ["opaque/first", "opaque/second"].into_iter().enumerate() {
            let item = serde_json::json!({"type":"response.output_item.done","output_index":index,
                "item":{"type":"reasoning","id":format!("reasoning-{index}"),"status":"completed",
                        "summary":[],"encrypted_content":state}});
            let encoded = serde_json::to_string(&item)
                .unwrap()
                .replace(":", ": ")
                .replace("opaque", "\\u006fpaque");
            let wire = format!("data: {encoded}\n\n");
            let mut units = Vec::new();
            for chunk in wire.as_bytes().chunks(7) {
                units.extend(projector.feed(chunk, false).unwrap());
            }
            assert_eq!(units.len(), 1);
            let delivered = units.pop().unwrap().bytes;
            assert_eq!(delivered, wire.as_bytes());
            frames.push(delivered);
        }
        frames
    })
    .await;
    let request = |state| serde_json::json!({"model":"state-test","input":[{"type":"reasoning","summary":[], "encrypted_content":state}]});
    for state in ["opaque/first", "opaque/second"] {
        let decoded =
            adapters::decode_ingress_request(IngressProtocol::Responses, &request(state)).unwrap();
        let mut target = profile.clone();
        target.capability.request.provider_state = profiles::Fidelity::Exact;
        let forwarded = adapters::project_candidate_request(&decoded, &target).unwrap();
        assert_eq!(forwarded.body["input"][0]["encrypted_content"], state);
    }
    let observation = observation::accepted_request_for_runtime_test();
    let mut downstream = FailSecondBodyWrite {
        writes: 0,
        accepted: Vec::new(),
    };
    let mut session = ReplayBodySession {
        inner: &mut downstream,
        request_head: request_head(),
        request_body: None,
        budget: budget(),
        response_capture: AcceptedResponseCapture::new(observation),
        response_started: true,
        runtime_state_authority: Default::default(),
        continuation_scanner: active.scanner(),
    };
    session
        .write_response_body(Bytes::from(frames[0].clone()), false)
        .await
        .unwrap();
    assert!(
        session
            .write_response_body(Bytes::from(frames[1].clone()), false)
            .await
            .is_err()
    );
    for state in ["opaque/first", "opaque/second"] {
        let decoded =
            adapters::decode_ingress_request(IngressProtocol::Responses, &request(state)).unwrap();
        let mut target = profile.clone();
        target.capability.request.provider_state = profiles::Fidelity::Exact;
        let forwarded = adapters::project_candidate_request(&decoded, &target).unwrap();
        assert_eq!(forwarded.body["input"][0]["encrypted_content"], state);
    }
}

fn request_head() -> GatewayRequestHead {
    GatewayRequestHead {
        method: Method::POST,
        path_and_query: Arc::from("/v1/responses"),
        authority: Some(Arc::from("gateway.test")),
        headers: HeaderMap::new(),
        protocol: HttpProtocol::Http1,
    }
}

fn budget() -> StreamBudget {
    BudgetTree::new(1024 * 1024, 1024 * 1024)
        .unwrap()
        .stream(512 * 1024)
        .unwrap()
}