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.

7.2 KB
Raw Blame
use super::*;
use crate::server::core_runtime::profiles::{
    CandidateProtocolProfile, ClientProtocolProfile, fixed_reasoning,
};
use hiroute_gateway_core::runtime::body::{BodyDirection, BodyPlan, BodyPlanExecutor, BudgetTree};
use serde_json::json;

#[test]
fn accepted_codex_terminal_event_crosses_transport_frames_and_keeps_eos() {
    let tree = BudgetTree::new(8 * 1024 * 1024, 8 * 1024 * 1024).unwrap();
    let budget = tree.stream(8 * 1024 * 1024).unwrap();
    let plan = BodyPlan::PassThrough {
        max_chunk_bytes: 64 * 1024,
    };
    let prefix =
        ChargedBodyQueue::new(&budget, MemoryRole::ResponsePrefix, &plan, 256 * 1024, 64).unwrap();
    let profile = CandidateProtocolProfile::exact_portable_path(
        IngressProtocol::Responses,
        IngressProtocol::Responses,
        "physical",
        fixed_reasoning("fixed"),
    );
    let projector = adapters::NativeResponseProjector::new_for_attempt(
        &profile,
        true,
        "alias".into(),
        None,
        budget.clone(),
    )
    .unwrap();
    let mut readiness = ProductionReadiness {
        #[cfg(all(unix, debug_assertions))]
        capture: None,
        response_status: StatusCode::OK,
        content_type: "text/event-stream",
        prefix,
        terminal_body: None,
        decoder: None,
        renderer: None,
        projector: Some(Box::new(projector)),
        _chat_tool_projection_budget: None,
        budget: budget.clone(),
        streaming: true,
        prefix_eos_pending: false,
        prefix_terminal_chunks: None,
        semantic_terminal: None,
    };
    // CPA repeats the request's instructions and tool schema in the
    // terminal response. This legal SSE event is larger than one 64 KiB
    // accepted-response transport frame.
    let terminal = json!({
        "type":"response.completed",
        "response":{
            "id":"response","model":"physical","status":"completed",
            "instructions":"x".repeat(100_000),
            "output":[{"type":"message","id":"message","role":"assistant",
                "status":"completed","content":[{"type":"output_text","text":"DONE"}]}]
        }
    });
    let wire = format!("event: response.completed\ndata: {terminal}\n\ndata: [DONE]\n\n");
    let input =
        ChargedBytes::copy_from_opaque(&budget, MemoryRole::ResponsePrefix, wire.as_bytes())
            .unwrap();
    let first = encode_accepted_event(
        &mut readiness,
        ProviderAcceptedEvent::Raw(PrecommitEvent::Body(input)),
    )
    .unwrap();
    assert!(first.is_none());
    assert!(
        take_accepted_prefix(&mut readiness).is_none(),
        "do not let the client observe response.completed before its EOF certificate can accompany the same final write"
    );
    let first = encode_accepted_event(
        &mut readiness,
        ProviderAcceptedEvent::Raw(PrecommitEvent::EndStream),
    )
    .unwrap();
    let mut accepted =
        BodyPlanExecutor::new(BodyDirection::AcceptedResponse, plan, 1024 * 1024).unwrap();
    let mut reconstructed = Vec::new();
    let mut frames = 0;
    let mut eos = 0;
    let mut next = first;
    loop {
        let frame = match next.take() {
            Some(frame) => frame,
            None => match take_accepted_prefix(&mut readiness) {
                Some(event) => encode_accepted_event(&mut readiness, event)
                    .unwrap()
                    .unwrap(),
                None => break,
            },
        };
        if let Some(output) = frame.output {
            let bytes = output.bytes.bytes();
            accepted.admit_chunk(bytes.len()).unwrap();
            reconstructed.extend_from_slice(bytes);
            frames += 1;
        }
        eos += usize::from(frame.end_stream);
        if frame.end_stream {
            assert_eq!(accepted.finish().unwrap(), reconstructed.len());
        }
    }
    assert!(frames >= 2);
    assert_eq!(eos, 1);
    assert!(reconstructed.starts_with(b"event: response.completed\n"));
    assert!(reconstructed.ends_with(b"data: [DONE]\n\n"));
    assert!(
        std::str::from_utf8(&reconstructed)
            .unwrap()
            .contains("\"model\":\"alias\"")
    );
    assert_eq!(
        readiness.semantic_terminal,
        Some(SemanticTerminalOutcome::Complete)
    );
}

#[test]
fn accepted_chat_terminal_closes_responses_stream_without_waiting_for_transport_eof() {
    let tree = BudgetTree::new(8 * 1024 * 1024, 8 * 1024 * 1024).unwrap();
    let budget = tree.stream(8 * 1024 * 1024).unwrap();
    let plan = BodyPlan::PassThrough {
        max_chunk_bytes: 64 * 1024,
    };
    let prefix =
        ChargedBodyQueue::new(&budget, MemoryRole::ResponsePrefix, &plan, 256 * 1024, 64).unwrap();
    let profile = CandidateProtocolProfile::exact_portable_path(
        IngressProtocol::Responses,
        IngressProtocol::ChatCompletions,
        "physical",
        fixed_reasoning("fixed"),
    );
    let client = ClientProtocolProfile::for_candidate(&profile).unwrap();
    let mut readiness = ProductionReadiness {
        #[cfg(all(unix, debug_assertions))]
        capture: None,
        response_status: StatusCode::OK,
        content_type: "text/event-stream",
        prefix,
        terminal_body: None,
        decoder: Some(
            adapters::NativeResponseDecoder::new_for_attempt(
                &profile,
                200,
                true,
                None,
                budget.clone(),
            )
            .unwrap(),
        ),
        renderer: Some(adapters::IncrementalClientSseRenderer::new(client, "alias").unwrap()),
        projector: None,
        _chat_tool_projection_budget: None,
        budget: budget.clone(),
        streaming: true,
        prefix_eos_pending: false,
        prefix_terminal_chunks: None,
        semantic_terminal: None,
    };
    let terminal = json!({
        "id": "chat", "object": "chat.completion.chunk", "created": 1,
        "model": "physical",
        "choices": [{"index": 0, "delta": {"role": "assistant", "content": "DONE"},
            "finish_reason": "stop"}],
        "usage": {"prompt_tokens": 4, "completion_tokens": 2, "total_tokens": 6}
    });
    let wire = format!("data: {terminal}\n\ndata: [DONE]\n\n");
    let input =
        ChargedBytes::copy_from_opaque(&budget, MemoryRole::ResponsePrefix, wire.as_bytes())
            .unwrap();
    assert!(
        encode_accepted_event(
            &mut readiness,
            ProviderAcceptedEvent::Raw(PrecommitEvent::Body(input)),
        )
        .unwrap()
        .is_none()
    );
    let mut reconstructed = Vec::new();
    let mut eos = 0;
    while let Some(event) = take_accepted_prefix(&mut readiness) {
        let frame = encode_accepted_event(&mut readiness, event)
            .unwrap()
            .unwrap();
        if let Some(output) = frame.output {
            reconstructed.extend_from_slice(output.bytes.bytes());
        }
        eos += usize::from(frame.end_stream);
    }
    assert_eq!(eos, 1, "the semantic terminal must carry downstream EOS");
    let rendered = std::str::from_utf8(&reconstructed).unwrap();
    assert!(rendered.contains("event: response.completed"));
    assert!(rendered.contains("\"input_tokens\":4"));
    assert_eq!(
        readiness.semantic_terminal,
        Some(SemanticTerminalOutcome::Complete)
    );
}