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.7 KB
Raw Blame
use std::io::Write;
use std::path::Path;
use std::process::{Command, Stdio};

use serde_json::{Value, json};

fn invoke(root: &Path, arguments: &[&str], input: &[u8]) -> (i32, Value) {
    let mut child = Command::new(env!("CARGO_BIN_EXE_hiroute"))
        .args(arguments)
        .env("HIROUTE_RUNTIME_DIR", root)
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .unwrap();
    let _ = child.stdin.take().unwrap().write_all(input);
    let output = child.wait_with_output().unwrap();
    let envelope = serde_json::from_slice(&output.stdout).unwrap_or_else(|_| {
        panic!(
            "invalid CLI response: {}",
            String::from_utf8_lossy(&output.stdout)
        )
    });
    (output.status.code().unwrap(), envelope)
}

fn facts() -> Vec<u8> {
    serde_json::to_vec(&json!({
        "schema":"hiroute.observation.query/v2",
        "intent":{"view":"facts","query":{
            "request_id":"request/one", "limit":100, "cursor":null
        }}
    }))
    .unwrap()
}

#[test]
fn unknown_options_never_become_resource_ids_or_reach_transport() {
    let root = tempfile::tempdir().unwrap();
    for path in [
        vec!["sessions", "receipt"],
        vec!["sessions", "show"],
        vec!["routing", "show"],
        vec!["compute", "show"],
        vec!["agents", "connect", "status"],
        vec!["agents", "check"],
        vec!["operations", "get"],
    ] {
        for invalid_id in ["--unknown", "-x", ""] {
            let mut args = path.clone();
            args.extend([invalid_id, "--output", "json"]);
            let (exit, envelope) = invoke(root.path(), &args, b"");
            assert_eq!(exit, 2, "{args:?}: {envelope}");
            assert_eq!(envelope["error"]["code"], "INVALID_ARGUMENTS");
        }
    }
}

#[test]
fn facts_file_and_stdin_parse_before_the_same_transport_boundary() {
    let root = tempfile::tempdir().unwrap();
    let path = root.path().join("事实 request.json");
    let input = facts();
    std::fs::write(&path, &input).unwrap();
    for (args, stdin) in [
        (
            vec![
                "sessions",
                "receipt",
                "--request-file",
                path.to_str().unwrap(),
                "--output",
                "json",
            ],
            b"malformed unused stdin".as_slice(),
        ),
        (
            vec!["sessions", "receipt", "--request-stdin", "--output", "json"],
            input.as_slice(),
        ),
        (
            vec!["sessions", "receipt", "receipt/one", "--output", "json"],
            b"ignored legacy stdin".as_slice(),
        ),
    ] {
        let (exit, envelope) = invoke(root.path(), &args, stdin);
        assert_eq!(exit, 6, "{args:?}: {envelope}");
        assert_eq!(envelope["error"]["code"], "DAEMON_UNAVAILABLE");
    }
}

#[test]
fn both_sources_reject_wrong_intents_unknown_fields_and_ambiguous_json() {
    let root = tempfile::tempdir().unwrap();
    let path = root.path().join("request.json");
    for bytes in [
        br#"{"schema":"hiroute.observation.query/v2","intent":{"view":"facts","query":{"request_id":"one","request_id":"two","limit":100}}}"#.as_slice(),
        br#"{"schema":"hiroute.observation.query/v2","intent":{"view":"facts","query":{"request_id":"one","limit":100,"secret":"reject"}}}"#,
        br#"{"schema":"hiroute.observation.query/v2","intent":{"view":"status","query":{}}}"#,
        b"{} {}", b"", b"\xff", b"{",
    ] {
        std::fs::write(&path, bytes).unwrap();
        for (args, stdin) in [
            (vec!["sessions", "receipt", "--request-file", path.to_str().unwrap()], b"unused".as_slice()),
            (vec!["sessions", "receipt", "--request-stdin"], bytes),
        ] {
            let (exit, envelope) = invoke(root.path(), &args, stdin);
            assert_eq!(exit, 2, "{args:?}: {envelope}");
            assert_eq!(envelope["error"]["code"], "INVALID_ARGUMENTS");
        }
    }
}

#[test]
fn typed_requests_reject_nested_unknowns_and_keep_declared_optional_and_dynamic_fields() {
    let root = tempfile::tempdir().unwrap();
    let file = root.path().join("typed.json");
    let agent = json!({"spec":{
        "schema_version":{"major":2,"minor":0},
        "context_id":"agent-context/codex/test",
        "model":{"intent":"restore","restore_point_ref":"model-restore/original"},
        "collaboration":{"intent":"keep"},
        "access_token":{"intent":"keep"},
        "restore_native_model":null,"protected_native_model_ids":[]
    }});
    let decision = json!({
        "schema_version":{"major":1,"minor":0},
        "spec":{
            "schema_version":{"major":1,"minor":0},
            "command_id":"decision.services.apply","resource_id":null,
            "desired_state":{"arbitrary":{"intent":"keep","typo":1}}
        }
    });
    let mut cases = vec![
        (vec!["agents", "connect", "preview"], agent.clone(), 6),
        (vec!["decision", "services", "apply"], decision.clone(), 6),
    ];
    let mut positional_spec = decision.clone();
    positional_spec["schema_version"] = json!([1, 0]);
    positional_spec["spec"] = json!([
        {"major":1,"minor":0}, "decision.services.apply", null, {"arbitrary":1}
    ]);
    cases.push((
        vec!["decision", "services", "apply"],
        positional_spec.clone(),
        6,
    ));
    positional_spec["spec"][0]["typo"] = Value::Null;
    cases.push((vec!["decision", "services", "apply"], positional_spec, 2));
    let mut authorization = json!({"action":"result","operation":{
        "operation_id":"operation/one","state":"succeeded","sequence":1,"cancellable":false
    }});
    cases.push((
        vec!["compute", "connection", "authorize"],
        authorization.clone(),
        6,
    ));
    authorization["operation"]["typo"] = Value::Null;
    cases.push((vec!["compute", "connection", "authorize"], authorization, 2));
    for pointer in [
        "/spec/schema_version/typo",
        "/spec/model/typo",
        "/spec/collaboration/typo",
        "/spec/access_token/typo",
    ] {
        let mut request = agent.clone();
        let (parent, key) = pointer.rsplit_once('/').unwrap();
        request.pointer_mut(parent).unwrap()[key] = Value::Null;
        cases.push((vec!["agents", "connect", "preview"], request, 2));
    }
    let mut keep = agent.clone();
    keep["spec"]["model"] = json!({"intent":"keep","typo":null});
    cases.push((vec!["agents", "connect", "preview"], keep, 2));
    let mut regenerate = agent.clone();
    regenerate["spec"]["access_token"] = json!({"intent":"regenerate","typo":null});
    cases.push((vec!["agents", "connect", "preview"], regenerate, 2));
    let mut apply = agent.clone();
    apply["accept_digest"] = json!(format!("sha256:{}", "0".repeat(64)));
    apply["dependency_digest"] = apply["accept_digest"].clone();
    apply["idempotency_key"] = json!("regression-only");
    apply["expected_revisions"] = json!({"target":0,"dependencies":{"arbitrary":1}});
    apply["login_item"] = Value::Null;
    cases.push((vec!["agents", "connect", "apply"], apply.clone(), 6));
    apply["expected_revisions"]["typo"] = Value::Null;
    cases.push((vec!["agents", "connect", "apply"], apply, 2));
    for pointer in [
        "/schema_version/typo",
        "/spec/schema_version/typo",
        "/spec/typo",
    ] {
        let mut request = decision.clone();
        let (parent, key) = pointer.rsplit_once('/').unwrap();
        request.pointer_mut(parent).unwrap()[key] = Value::Null;
        cases.push((vec!["decision", "services", "apply"], request, 2));
    }
    for (path, request, expected_exit) in cases {
        let bytes = serde_json::to_vec(&request).unwrap();
        std::fs::write(&file, &bytes).unwrap();
        for source in [
            vec!["--request-file", file.to_str().unwrap()],
            vec!["--request-stdin"],
        ] {
            let mut args = path.clone();
            args.extend(source);
            let (exit, envelope) = invoke(root.path(), &args, &bytes);
            assert_eq!(exit, expected_exit, "{args:?} {request}: {envelope}");
            assert_eq!(
                envelope["error"]["code"],
                if expected_exit == 2 {
                    "INVALID_ARGUMENTS"
                } else {
                    "DAEMON_UNAVAILABLE"
                }
            );
        }
    }
}

#[test]
fn conflicting_missing_and_nonregular_request_files_are_usage_errors() {
    let root = tempfile::tempdir().unwrap();
    let path = root.path().join("request.json");
    std::fs::write(&path, facts()).unwrap();
    for options in [
        vec!["--request-file"],
        vec!["--request-file", ""],
        vec!["--request-file", "--request-stdin"],
        vec!["--request-file", "missing-request.json"],
        vec!["--request-file", root.path().to_str().unwrap()],
        vec!["--request-file", path.to_str().unwrap(), "--request-stdin"],
        vec!["--request-stdin", "--request-file", path.to_str().unwrap()],
        vec![
            "--request-file",
            path.to_str().unwrap(),
            "--request-file",
            path.to_str().unwrap(),
        ],
        vec!["--request-stdin", "--request-stdin"],
        vec!["receipt/one", "--request-file", path.to_str().unwrap()],
    ] {
        let mut args = vec!["sessions", "receipt"];
        args.extend(options);
        let (exit, envelope) = invoke(root.path(), &args, &facts());
        assert_eq!(exit, 2, "{args:?}: {envelope}");
        assert_eq!(envelope["error"]["code"], "INVALID_ARGUMENTS");
    }
}

#[test]
fn budget_detail_opt_in_preserves_legacy_inputs_across_both_sources() {
    let root = tempfile::tempdir().unwrap();
    let file = root.path().join("budget-projection.json");
    let digest = format!("sha256:{}", "0".repeat(64));
    let lookup = json!({
        "principal_kind":"interactive_user", "operation_kind":"change",
        "idempotency_key":"test", "accepted_digest":digest
    });
    let publication = json!({
        "change":{
            "schema":"hiroute.plan-content-change/v2",
            "target":{"intent":"create","creation_key":"budget-compatibility"},
            "editor":{
                "schema":"hiroute.plan-editor/v2", "display_name":"Budget compatibility",
                "purpose":"Check request projection", "mode":"fixed_model", "candidates":[],
                "smart":{
                    "economy":[], "primary":[],
                    "judgment":hiroute_domain::JudgmentSettingsV1::default(),
                    "reselect_on_user_message":false, "classifier":{"kind":"local_rules"},
                    "complex_keywords":[]
                },
                "free":{"candidates":[],"primary":[],"primary_fallback":false},
                "delegation_enabled":false,
                "requirements":hiroute_domain::CapabilityRequirementsV1::default(),
                "limits":{"maximum_attempts":1,"request_timeout_ms":1000,"attempt_timeout_ms":1000}
            },
            "consumed_draft":null
        },
        "accept_digest":digest, "expected_revisions":{"target":0},
        "idempotency_key":"budget-compatibility"
    });
    for (path, original) in [
        (vec!["operations", "find"], lookup),
        (
            vec!["operations", "find"],
            json!(["interactive_user", "change", "test", digest]),
        ),
        (vec!["routing", "apply"], publication),
    ] {
        for projection in [None, Some(false), Some(true)] {
            let mut request = original.clone();
            if let Some(projection) = projection {
                if let Some(fields) = request.as_array_mut() {
                    fields.push(json!(projection));
                } else {
                    request["include_model_budget_conflict"] = json!(projection);
                }
            }
            let bytes = serde_json::to_vec(&request).unwrap();
            std::fs::write(&file, &bytes).unwrap();
            for source in [
                vec!["--request-file", file.to_str().unwrap()],
                vec!["--request-stdin"],
            ] {
                let mut args = path.clone();
                args.extend(source);
                let (exit, envelope) = invoke(root.path(), &args, &bytes);
                // A syntactically valid request reaches transport; no daemon or grant is created.
                assert_eq!(exit, 6, "{args:?} {request}: {envelope}");
                assert_eq!(envelope["error"]["code"], "DAEMON_UNAVAILABLE");
            }
        }
    }
}

#[test]
fn existing_per_command_byte_limits_apply_to_files_and_stdin() {
    let root = tempfile::tempdir().unwrap();
    for (path, limit, request) in [
        (
            vec!["operations", "find"],
            65_536,
            json!({
                "principal_kind":"interactive_user","operation_kind":"change",
                "idempotency_key":"test","accepted_digest":format!("sha256:{}", "0".repeat(64))
            }),
        ),
        (
            vec!["worker", "dependencies", "select"],
            65_536,
            json!({
                "harness":"codex_cli","cli_path":"/tmp/hiroute-request-test/codex",
                "adapter_path":"/tmp/hiroute-request-test/codex-acp",
                "expected_selection_revision":0
            }),
        ),
        (vec!["routing", "options"], 1024 * 1024, json!({})),
    ] {
        // Whitespace is valid JSON framing, so oversize cannot hide behind syntax rejection.
        let mut bytes = serde_json::to_vec(&request).unwrap();
        for (size, expected_exit, expected_code) in [
            (limit, 6, "DAEMON_UNAVAILABLE"),
            (limit + 1, 2, "INVALID_ARGUMENTS"),
        ] {
            bytes.resize(size, b' ');
            let file = root.path().join("bounded.json");
            std::fs::write(&file, &bytes).unwrap();
            for source in [
                vec!["--request-file", file.to_str().unwrap()],
                vec!["--request-stdin"],
            ] {
                let mut args = path.clone();
                args.extend(source);
                args.extend(["--output", "json"]);
                let (exit, envelope) = invoke(root.path(), &args, &bytes);
                assert_eq!(exit, expected_exit, "{args:?}: {envelope}");
                assert_eq!(envelope["error"]["code"], expected_code);
            }
        }
    }
}

#[cfg(unix)]
#[test]
fn a_request_fifo_without_a_writer_is_rejected_without_opening_a_stream() {
    let root = tempfile::tempdir().unwrap();
    let fifo = root.path().join("request.pipe");
    nix::unistd::mkfifo(
        &fifo,
        nix::sys::stat::Mode::S_IRUSR | nix::sys::stat::Mode::S_IWUSR,
    )
    .unwrap();
    let (exit, envelope) = invoke(
        root.path(),
        &[
            "sessions",
            "receipt",
            "--request-file",
            fifo.to_str().unwrap(),
        ],
        b"",
    );
    assert_eq!(exit, 2, "{envelope}");
    assert_eq!(envelope["error"]["code"], "INVALID_ARGUMENTS");
}