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.

14.5 KB
Raw Blame
use super::*;

#[test]
fn responses_easy_input_messages_preserve_the_same_context_as_explicit_messages() {
    let input = json!([
        {"role":"system","content":"routing rules"},
        {"role":"user","content":[{"type":"input_text","text":"inspect the file"}]},
        {"role":"assistant","content":"done","phase":"final_answer"}
    ]);
    let mut explicit = input.clone();
    for message in explicit.as_array_mut().unwrap() {
        message["type"] = "message".into();
    }
    let decode = |input| {
        decode_ingress_request(
            IngressProtocol::Responses,
            &json!({"model":"alias","input":input}),
        )
    };
    let mut easy = decode(input.clone()).unwrap();
    let mut typed = decode(explicit.clone()).unwrap();
    assert_eq!(
        easy.native_body.take(),
        Some(json!({"model":"alias","input":input}))
    );
    assert_eq!(
        typed.native_body.take(),
        Some(json!({"model":"alias","input":explicit}))
    );
    assert_eq!(
        easy, typed,
        "Equivalent messages preserve canonical context and metadata"
    );
    for invalid in [
        json!({"role":"user"}),
        json!({"content":"no role"}),
        json!({"type":null,"role":"user","content":"bad type"}),
    ] {
        assert!(decode(json!([invalid])).is_err());
    }
}

#[test]
fn responses_previous_response_id_has_an_explicit_http_boundary() {
    for body in [
        json!({"model":"alias","input":"hello"}),
        json!({"model":"alias","input":"hello","previous_response_id":null}),
    ] {
        let request = decode_ingress_request(IngressProtocol::Responses, &body).unwrap();
        assert!(request.provider_state.is_empty());
    }
    for value in [json!("response"), json!({"id":"response"})] {
        let error = decode_ingress_request(
            IngressProtocol::Responses,
            &json!({"model":"alias","input":"hello","previous_response_id":value}),
        )
        .unwrap_err();
        assert_eq!(error, ModelIrError::ResponsesPreviousResponseIdUnsupported);
        assert_eq!(
            ProtocolAdapterError::from(error).code(),
            "RESPONSES_PREVIOUS_RESPONSE_ID_UNSUPPORTED"
        );
    }
    for value in [json!(true), json!(1), json!([])] {
        assert_eq!(
            decode_ingress_request(
                IngressProtocol::Responses,
                &json!({"model":"alias","input":"hello","previous_response_id":value}),
            ),
            Err(ModelIrError::InvalidField("previous_response_id"))
        );
    }
}

#[test]
fn responses_conversation_never_borrows_reasoning_ciphertext_owner() {
    for input in [
        json!("continue"),
        json!([
            {"type":"reasoning","summary":[],"encrypted_content":"luna-state"},
            {"type":"message","role":"user","content":[{"type":"input_text","text":"continue"}]}
        ]),
    ] {
        let error = decode_ingress_request(
            IngressProtocol::Responses,
            &json!({"model":"alias","input":input,"conversation":"conversation-1"}),
        )
        .unwrap_err();
        assert_eq!(error, ModelIrError::ResponsesConversationUnsupported);
        assert_eq!(
            ProtocolAdapterError::from(error).code(),
            "RESPONSES_CONVERSATION_UNSUPPORTED"
        );
    }
}

#[test]
fn responses_to_messages_keeps_top_level_instructions_and_tool_history_but_rejects_mid_roles() {
    let profile = CandidateProtocolProfile::exact_portable_path(
        IngressProtocol::Responses,
        IngressProtocol::Messages,
        "glm-5.3",
        fixed_reasoning("fixed"),
    );
    let request = decode_ingress_request(
        IngressProtocol::Responses,
        &json!({
            "model": "route", "stream": true, "instructions": "top-level policy",
            "input": [
                {"type":"message","role":"user","content":[{"type":"input_text","text":"first turn"}]},
                {"type":"message","role":"assistant","content":[{"type":"output_text","text":"checking"}]},
                {"type":"function_call","call_id":"logical-call","name":"lookup","arguments":"{\"key\":\"v\"}"},
                {"type":"function_call_output","call_id":"logical-call","output":"result"},
                {"type":"message","role":"user","content":[{"type":"input_text","text":"next turn"}]}
            ],
            "tools": [{"type":"function","name":"lookup","parameters":{"type":"object"}}],
            "tool_choice": "auto", "parallel_tool_calls": false
        }),
    )
    .unwrap();
    assert!(!request.requirements().mid_conversation_instructions);
    let body = project_candidate_request(&request, &profile).unwrap().body;
    assert_eq!(body["model"], "glm-5.3");
    assert_eq!(body["system"], "top-level policy");
    assert_eq!(body["stream"], true);
    assert_eq!(body["messages"][0]["content"][0]["text"], "first turn");
    assert_eq!(body["messages"][1]["content"][0]["text"], "checking");
    assert_eq!(body["messages"][2]["content"][0]["id"], "logical-call");
    assert_eq!(
        body["messages"][2]["content"][0]["input"],
        json!({"key":"v"})
    );
    assert_eq!(
        body["messages"][3]["content"][0]["tool_use_id"],
        "logical-call"
    );
    assert_eq!(body["messages"][4]["content"][0]["text"], "next turn");
    assert_eq!(
        body["tool_choice"],
        json!({"type":"auto","disable_parallel_tool_use":true})
    );

    let mut mid = request.clone();
    mid.messages.insert(
        1,
        crate::server::core_runtime::model_ir::CanonicalMessage {
            role: MessageRole::Developer,
            content: vec![ContentPart::Text {
                text: "late policy".into(),
            }],
            name: None,
        },
    );
    assert!(mid.requirements().mid_conversation_instructions);
    assert!(matches!(
        project_candidate_request(&mid, &profile),
        Err(ProtocolAdapterError::ClientUnrepresentable(_))
    ));
}

#[test]
fn codex_input_developer_prelude_is_initial_but_not_messages_representable() {
    let document = json!({
        "model": "route", "stream": true,
        "input": [
            {"type":"message","role":"developer","content":[{"type":"input_text","text":"bounds"}]},
            {"type":"message","role":"user","content":[{"type":"input_text","text":"first turn"}]},
            {"type":"message","role":"assistant","content":[{"type":"output_text","text":"checking"}]},
            {"type":"function_call","call_id":"logical-call","name":"lookup","arguments":"{\"key\":\"v\"}"},
            {"type":"function_call_output","call_id":"logical-call","output":"result"},
            {"type":"message","role":"user","content":[{"type":"input_text","text":"next turn"}]}
        ],
        "tools": [{"type":"function","name":"lookup","parameters":{"type":"object"}}],
        "tool_choice": "auto", "parallel_tool_calls": false
    });
    let request = decode_ingress_request(IngressProtocol::Responses, &document).unwrap();
    let requirements = request.requirements();
    assert!(requirements.initial_instructions);
    assert!(!requirements.mid_conversation_instructions);
    assert!(requirements.function_tools && requirements.streaming);

    let native = CandidateProtocolProfile::exact_portable_path(
        IngressProtocol::Responses,
        IngressProtocol::Responses,
        "physical",
        fixed_reasoning("fixed"),
    );
    let projected = project_candidate_request(&request, &native).unwrap().body;
    assert_eq!(projected["input"][0]["role"], "developer");
    assert_eq!(projected["input"][3]["call_id"], "logical-call");
    assert_eq!(projected["input"][5]["content"][0]["text"], "next turn");
    assert_eq!(projected["stream"], true);

    let messages = CandidateProtocolProfile::exact_portable_path(
        IngressProtocol::Responses,
        IngressProtocol::Messages,
        "physical",
        fixed_reasoning("fixed"),
    );
    assert!(matches!(
        project_candidate_request(&request, &messages),
        Err(ProtocolAdapterError::ClientUnrepresentable(message))
            if message.contains("distinct Responses input system/developer role")
    ));

    let mut mid = document;
    mid["input"][5] = json!({"type":"message","role":"developer","content":[{"type":"input_text","text":"late bounds"}]});
    let mid = decode_ingress_request(IngressProtocol::Responses, &mid).unwrap();
    assert!(mid.requirements().mid_conversation_instructions);
    assert!(matches!(
        project_candidate_request(&mid, &messages),
        Err(ProtocolAdapterError::ClientUnrepresentable(_))
    ));
}

#[test]
fn responses_replayed_plain_reasoning_uses_the_existing_bounded_body_path() {
    let native = json!({"model":"alias","input":[{
        "type":"reasoning","id":"reasoning-item","summary":[],
        "content":[{"type":"reasoning_text","text":"plain reasoning ".repeat(4096)}],
        "provider_extension":{"version":1},"encrypted_content":null
    }]});
    let mut request = decode_ingress_request(IngressProtocol::Responses, &native).unwrap();
    let profile = CandidateProtocolProfile::exact_portable_path(
        IngressProtocol::Responses,
        IngressProtocol::Responses,
        "physical",
        fixed_reasoning("fixed"),
    );
    let expected = project_candidate_request(&request, &profile).unwrap().bytes;
    assert_eq!(
        serde_json::from_slice::<serde_json::Value>(&expected).unwrap()["input"],
        native["input"]
    );
    let cross_protocol = CandidateProtocolProfile::exact_portable_path(
        IngressProtocol::Responses,
        IngressProtocol::ChatCompletions,
        "physical",
        fixed_reasoning("fixed"),
    );
    let chat = project_candidate_request(&request, &cross_protocol).unwrap();
    assert!(
        chat.body["messages"]
            .as_array()
            .unwrap()
            .iter()
            .any(|message| message.get("reasoning_content").is_some())
    );

    let root = std::env::temp_dir().join(format!(
        "hiroute-reasoning-replay-{}-{}",
        std::process::id(),
        std::time::SystemTime::now()
            .duration_since(std::time::SystemTime::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    ));
    let manager = ReplayManager::open(ReplayConfig {
        root: root.clone(),
        memory_threshold_bytes: 128,
        record_bytes: 31,
        orphan_ttl: std::time::Duration::from_secs(60),
    })
    .unwrap();
    let budget = BudgetTree::new(4 * 1024 * 1024, 4 * 1024 * 1024)
        .unwrap()
        .stream(4 * 1024 * 1024)
        .unwrap();
    let store = manager.begin_request(budget.clone()).unwrap();
    externalize_model_request(&mut request, &store, 8).unwrap();
    let template = project_candidate_request_template(&request, &profile).unwrap();
    assert!(template.bytes.len() < expected.len());
    store.prevalidate(&model_content_refs(&request)).unwrap();
    let mut reader = sequential_attempt_body(template, store.clone(), &budget, 257).unwrap();
    let mut actual = Vec::new();
    while let Some(chunk) = reader.next_chunk().unwrap() {
        actual.extend_from_slice(chunk.bytes());
    }
    reader.release();
    assert_eq!(actual, expected);
    drop(reader);
    drop(store);
    drop(manager);
    assert_eq!(budget.snapshot().unwrap().live, 0);
    fs_err_remove_dir(&root);
}

#[test]
fn responses_multitool_continuation_replays_externalized_reasoning_state() {
    let profile = exact_state_profile(IngressProtocol::Responses, IngressProtocol::Responses);
    let opaque_first = "first-state".repeat(180);
    let opaque_second = "second-state".repeat(130);
    let mut request = decode_ingress_request(
        IngressProtocol::Responses,
        &json!({
            "model":"alias",
            "input":[
                {"type":"message","role":"user","content":[{"type":"input_text","text":"run two commands"}]},
                {"type":"reasoning","summary":[],"content":null,"encrypted_content":opaque_first},
                {"type":"message","role":"assistant","content":[{"type":"output_text","text":"first"}]},
                {"type":"function_call","call_id":"call-1","name":"shell","arguments":"{\"command\":\"one\"}"},
                {"type":"function_call_output","call_id":"call-1","output":"done one"},
                {"type":"reasoning","summary":[],"content":null,"encrypted_content":opaque_second},
                {"type":"message","role":"assistant","content":[{"type":"output_text","text":"second"}]},
                {"type":"function_call","call_id":"call-2","name":"shell","arguments":"{\"command\":\"two\"}"},
                {"type":"function_call_output","call_id":"call-2","output":"done two"}
            ]
        }),
    )
    .expect("two round Responses history");
    let expected = project_candidate_request(&request, &profile)
        .expect("inline projection")
        .bytes;
    let root = std::env::temp_dir().join(format!(
        "hiroute-multitool-replay-{}-{}",
        std::process::id(),
        std::time::SystemTime::now()
            .duration_since(std::time::SystemTime::UNIX_EPOCH)
            .expect("clock")
            .as_nanos()
    ));
    let manager = ReplayManager::open(ReplayConfig {
        root: root.clone(),
        memory_threshold_bytes: 128,
        record_bytes: 31,
        orphan_ttl: std::time::Duration::from_secs(60),
    })
    .expect("replay manager");
    let tree = BudgetTree::new(4 * 1024 * 1024, 4 * 1024 * 1024).expect("budget tree");
    let budget = tree.stream(4 * 1024 * 1024).expect("stream budget");
    let store = manager.begin_request(budget.clone()).expect("replay store");
    externalize_model_request(&mut request, &store, 2300).expect("externalize late state");
    let states = request
        .messages
        .iter()
        .filter_map(|message| match message.content.first() {
            Some(ContentPart::ProviderState { state }) => Some(&state.value),
            _ => None,
        })
        .collect::<Vec<_>>();
    assert_eq!(states.len(), 2);
    assert!(states[0].content_ref().is_none());
    assert!(states[1].content_ref().is_some());
    let template = project_candidate_request_template(&request, &profile)
        .expect("externalized opaque continuation is still an exact Responses string");
    assert_eq!(template.wire_len, expected.len());
    store
        .prevalidate(&model_content_refs(&request))
        .expect("replay backing");
    let mut reader =
        sequential_attempt_body(template, store.clone(), &budget, 37).expect("attempt reader");
    let mut actual = Vec::new();
    while let Some(chunk) = reader.next_chunk().expect("continuation chunk") {
        actual.extend_from_slice(chunk.bytes());
    }
    reader.release();
    assert_eq!(actual, expected);
    drop(store);
    drop(manager);
    assert_eq!(budget.snapshot().expect("snapshot").live, 0);
    fs_err_remove_dir(&root);
}