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.

17.5 KB
Raw Blame
use super::*;

#[test]
fn codex_explicit_reasoning_reads_the_original_native_value() {
    assert_eq!(
        codex_explicit_reasoning_effort("model_reasoning_effort = 'high'\n").unwrap(),
        Some("high".to_owned())
    );
    assert_eq!(
        codex_explicit_reasoning_effort("model = 'native'\n").unwrap(),
        None
    );
    assert!(codex_explicit_reasoning_effort("model_reasoning_effort = 42\n").is_err());
}

#[test]
fn codex_protected_restore_record_survives_restart_and_keeps_user_changes() {
    let original = "# user's comment\nmodel = 'private-original'\ncustom = 3\n";
    let edit = configure(original, CodexSelectionTarget::Root).unwrap();
    let encoded = edit.restore.encode_protected().unwrap();
    let restored_record = CodexNativeRestore::decode_protected(&encoded).unwrap();
    let current = edit.rendered.replace("custom = 3", "custom = 4");
    let restored = restore_codex_native(&current, &restored_record).unwrap();
    assert_eq!(
        restored.as_str(),
        original.replace("custom = 3", "custom = 4")
    );
    assert!(CodexNativeRestore::decode_protected(b"{}").is_err());
    let mut corrupt: serde_json::Value = serde_json::from_slice(&encoded).unwrap();
    corrupt["fields"][0]["path"] = serde_json::json!(["user_private_key"]);
    assert!(CodexNativeRestore::decode_protected(&serde_json::to_vec(&corrupt).unwrap()).is_err());
}

fn configure(
    text: &str,
    target: CodexSelectionTarget,
) -> Result<CodexNativeEdit, CodexNativeError> {
    configure_codex_native(
        text,
        &CanonicalDigest::of_bytes(text.as_bytes()),
        target,
        "hiroute",
        "http://127.0.0.1:5837/v1",
        Some("hiroute/0011223344556677"),
        &AgentAccessGrantMaterial::from_csprng_entropy([3; 32]),
    )
}

#[test]
fn codex_native_preserves_comments_unknown_fields_and_original_provider() {
    let original = "# personal configuration\nmodel = 'old' # keep this\nmodel_provider = 'mine'\nunrelated = 42\n[model_providers.mine]\nbase_url = 'https://original.example'\nenv_key = 'PRIVATE_KEY'\n";
    let edit = configure(original, CodexSelectionTarget::Root).unwrap();
    assert!(edit.rendered.contains("# personal configuration"));
    assert!(edit.rendered.contains("# keep this"));
    assert!(edit.rendered.contains("env_key = 'PRIVATE_KEY'"));
    let parsed = edit.rendered.parse::<DocumentMut>().unwrap();
    assert_eq!(
        parsed["model_providers"]["hiroute"]["wire_api"].as_str(),
        Some("responses")
    );
    let provider = parsed["model_providers"]["hiroute"].as_table().unwrap();
    assert!(
        provider["http_headers"]["X-HiRoute-Token"]
            .as_str()
            .is_some()
    );
    assert_eq!(provider["requires_openai_auth"].as_bool(), Some(false));
    assert_eq!(provider["supports_websockets"].as_bool(), Some(false));
    for forbidden in [
        "experimental_bearer_token",
        "env_key",
        "env_http_headers",
        "auth_command",
    ] {
        assert!(!provider.contains_key(forbidden));
    }
    let user_edited = edit.rendered.replace("unrelated = 42", "unrelated = 43");
    let restored = restore_codex_native(&user_edited, &edit.restore).unwrap();
    assert_eq!(
        restored.as_str(),
        original.replace("unrelated = 42", "unrelated = 43")
    );
    assert_eq!(
        restore_codex_native(&restored, &edit.restore).unwrap(),
        restored
    );
}

#[test]
fn codex_native_profile_changes_are_scoped_and_existing_provider_is_not_claimed() {
    let original =
        "model = 'daily'\n[profiles.work]\nmodel = 'work'\n[profiles.other]\nmodel = 'other'\n";
    let edit = configure(original, CodexSelectionTarget::LegacyProfile("work".into())).unwrap();
    let parsed = edit.rendered.parse::<DocumentMut>().unwrap();
    assert_eq!(parsed["model"].as_str(), Some("daily"));
    assert_eq!(parsed["profiles"]["other"]["model"].as_str(), Some("other"));
    assert_eq!(
        parsed["profiles"]["work"]["model"].as_str(),
        Some("hiroute/0011223344556677")
    );
    assert!(matches!(
        configure(
            "[model_providers.hiroute]\nunknown = 1\n",
            CodexSelectionTarget::Root
        ),
        Err(CodexNativeError::ProviderAlreadyExists)
    ));
}

#[test]
fn codex_native_restore_conflict_and_added_user_field_never_get_overwritten() {
    let edit = configure("", CodexSelectionTarget::Root).unwrap();
    let mut changed = edit.rendered.parse::<DocumentMut>().unwrap();
    changed["model"] = toml_edit::value("my-new-choice");
    assert!(matches!(
        restore_codex_native(&changed.to_string(), &edit.restore),
        Err(CodexNativeError::FieldConflict)
    ));
    let mut changed = edit.rendered.parse::<DocumentMut>().unwrap();
    changed["model_providers"]["hiroute"]["user_extension"] = toml_edit::value("keep");
    let restored = restore_codex_native(&changed.to_string(), &edit.restore).unwrap();
    let parsed = restored.parse::<DocumentMut>().unwrap();
    assert_eq!(
        parsed["model_providers"]["hiroute"]["user_extension"].as_str(),
        Some("keep")
    );
    assert!(parsed.get("model").is_none());
}

#[test]
fn codex_native_rejects_duplicate_keys_and_stale_preview() {
    assert!(matches!(
        configure("model = 'one'\nmodel = 'two'\n", CodexSelectionTarget::Root),
        Err(CodexNativeError::InvalidToml)
    ));
    assert!(matches!(
        configure_codex_native(
            "model = 'changed'",
            &CanonicalDigest::of_bytes(b"old"),
            CodexSelectionTarget::Root,
            "hiroute",
            "http://127.0.0.1:5837/v1",
            Some("hiroute/0011223344556677"),
            &AgentAccessGrantMaterial::from_csprng_entropy([4; 32])
        ),
        Err(CodexNativeError::SourceChanged)
    ));
}

#[test]
fn codex_preserve_native_does_not_own_explicit_or_implicit_model() {
    for original in [
        "# implicit default\n",
        "model = 'Vendor/Native[1m]' # preserve\n",
    ] {
        let edit = configure_codex_native(
            original,
            &CanonicalDigest::of_bytes(original.as_bytes()),
            CodexSelectionTarget::Root,
            "hiroute",
            "http://127.0.0.1:5837/v1",
            None,
            &AgentAccessGrantMaterial::from_csprng_entropy([4; 32]),
        )
        .unwrap();
        assert!(
            edit.rendered.contains(original),
            "{}",
            edit.rendered.as_str()
        );
        let before = original.parse::<DocumentMut>().unwrap();
        let after = edit.rendered.parse::<DocumentMut>().unwrap();
        assert_eq!(
            before.get("model").map(Item::to_string),
            after.get("model").map(Item::to_string)
        );
        assert_eq!(
            restore_codex_native(&edit.rendered, &edit.restore)
                .unwrap()
                .as_str(),
            original
        );
        let record =
            CodexNativeRestore::decode_protected(&edit.restore.encode_protected().unwrap())
                .unwrap();
        let mut user_changed = after;
        user_changed["model"] = toml_edit::value("User/NewChoice");
        let restored = restore_codex_native(&user_changed.to_string(), &record).unwrap();
        assert_eq!(
            restored.parse::<DocumentMut>().unwrap()["model"].as_str(),
            Some("User/NewChoice")
        );
    }
}

#[test]
fn codex_preserve_native_restores_only_a_hiroute_route_alias() {
    for original in ["# implicit default\n", "model = 'native-original' # keep\n"] {
        let edit = configure_codex_native(
            original,
            &CanonicalDigest::of_bytes(original.as_bytes()),
            CodexSelectionTarget::Root,
            "hiroute",
            "http://127.0.0.1:5837/v1",
            None,
            &AgentAccessGrantMaterial::from_csprng_entropy([4; 32]),
        )
        .unwrap()
        .with_managed_aliases(&["hiroute-coding".into()])
        .unwrap();
        let restore =
            CodexNativeRestore::decode_protected(&edit.restore.encode_protected().unwrap())
                .unwrap();
        let mut active = edit.rendered.parse::<DocumentMut>().unwrap();
        active["model"] = toml_edit::value("hiroute-coding");
        let restored = restore_codex_native(&active.to_string(), &restore).unwrap();
        let restored = restored.parse::<DocumentMut>().unwrap();
        let initial = original.parse::<DocumentMut>().unwrap();
        assert_eq!(
            restored.get("model").and_then(Item::as_str),
            initial.get("model").and_then(Item::as_str)
        );
        assert!(restored.get("model_providers").is_none());

        let mut unrelated_alias = edit.rendered.parse::<DocumentMut>().unwrap();
        unrelated_alias["model"] = toml_edit::value("hiroute-other");
        let restored = restore_codex_native(&unrelated_alias.to_string(), &restore).unwrap();
        assert_eq!(
            restored.parse::<DocumentMut>().unwrap()["model"].as_str(),
            Some("hiroute-other")
        );

        let mut native_choice = edit.rendered.parse::<DocumentMut>().unwrap();
        native_choice["model"] = toml_edit::value("native-other");
        let restored = restore_codex_native(&native_choice.to_string(), &restore).unwrap();
        assert_eq!(
            restored.parse::<DocumentMut>().unwrap()["model"].as_str(),
            Some("native-other")
        );
    }
}

#[test]
fn stale_original_alias_can_be_repaired_with_an_explicit_native_model() {
    let original = "model = 'hiroute-fanyi'\nuser_option = true\n";
    let edit = configure_codex_native(
        original,
        &CanonicalDigest::of_bytes(original.as_bytes()),
        CodexSelectionTarget::Root,
        "hiroute",
        "http://127.0.0.1:5837/v1",
        None,
        &AgentAccessGrantMaterial::from_csprng_entropy([4; 32]),
    )
    .unwrap();
    let restore =
        CodexNativeRestore::decode_protected(&edit.restore.encode_protected().unwrap()).unwrap();
    let repaired =
        restore_codex_native_with_model(&edit.rendered, &restore, Some("gpt-5.6-sol")).unwrap();
    let parsed = repaired.parse::<DocumentMut>().unwrap();
    assert_eq!(parsed["model"].as_str(), Some("gpt-5.6-sol"));
    assert!(parsed.get("model_provider").is_none());
    assert!(parsed.get("model_providers").is_none());
    assert_eq!(parsed["user_option"].as_bool(), Some(true));
}

#[test]
fn codex_explicit_fixed_name_is_not_rewritten_as_a_plan_alias() {
    let edit = configure_codex_native(
        "",
        &CanonicalDigest::of_bytes(b""),
        CodexSelectionTarget::Root,
        "hiroute",
        "http://127.0.0.1:5837/v1",
        Some("Vendor/Native[1m]"),
        &AgentAccessGrantMaterial::from_csprng_entropy([4; 32]),
    )
    .unwrap();
    assert_eq!(
        edit.rendered.parse::<DocumentMut>().unwrap()["model"].as_str(),
        Some("Vendor/Native[1m]")
    );
}

#[test]
fn codex_catalog_pointer_restores_original_and_preserves_unrelated_changes() {
    let original = "model_catalog_json = '/user/original.json' # own catalog\ncustom = 1\n";
    let edit = configure(original, CodexSelectionTarget::Root)
        .unwrap()
        .with_model_catalog(&crate::agents::test_absolute_path(
            "/owned/catalog one.json",
        ))
        .unwrap();
    let parsed = edit.rendered.parse::<DocumentMut>().unwrap();
    assert_eq!(
        parsed["model_catalog_json"].as_str(),
        crate::agents::test_absolute_path("/owned/catalog one.json").to_str()
    );
    assert!(edit.rendered.contains("# own catalog"));
    let encoded = edit.restore.encode_protected().unwrap();
    let record = CodexNativeRestore::decode_protected(&encoded).unwrap();
    let changed = edit.rendered.replace("custom = 1", "custom = 2");
    assert_eq!(
        restore_codex_native(&changed, &record).unwrap().as_str(),
        original.replace("custom = 1", "custom = 2")
    );
}

#[test]
fn codex_catalog_pointer_is_scoped_to_the_selected_profile() {
    let original = "model_catalog_json = '/root.json'\n[profiles.work]\nmodel = 'work'\n[profiles.other]\nmodel_catalog_json = '/other.json'\n";
    let edit = configure(original, CodexSelectionTarget::LegacyProfile("work".into()))
        .unwrap()
        .with_model_catalog(&crate::agents::test_absolute_path("/owned/work.json"))
        .unwrap();
    let parsed = edit.rendered.parse::<DocumentMut>().unwrap();
    assert_eq!(parsed["model_catalog_json"].as_str(), Some("/root.json"));
    assert_eq!(
        parsed["profiles"]["other"]["model_catalog_json"].as_str(),
        Some("/other.json")
    );
    assert_eq!(
        parsed["profiles"]["work"]["model_catalog_json"].as_str(),
        crate::agents::test_absolute_path("/owned/work.json").to_str()
    );
    let record =
        CodexNativeRestore::decode_protected(&edit.restore.encode_protected().unwrap()).unwrap();
    assert_eq!(
        restore_codex_native(&edit.rendered, &record)
            .unwrap()
            .as_str(),
        original
    );
}

#[test]
fn codex_catalog_update_keeps_first_restore_point() {
    let original = "model_catalog_json = '/user/original.json'\n";
    let first = configure(original, CodexSelectionTarget::Root)
        .unwrap()
        .with_model_catalog(&crate::agents::test_absolute_path("/owned/first.json"))
        .unwrap();
    let second = reconfigure_codex_native(
        &first.rendered,
        &CanonicalDigest::of_bytes(first.rendered.as_bytes()),
        &first.restore,
        CodexSelectionTarget::Root,
        "hiroute",
        "http://127.0.0.1:5837/v1",
        None,
        &AgentAccessGrantMaterial::from_csprng_entropy([5; 32]),
    )
    .unwrap()
    .with_model_catalog(&crate::agents::test_absolute_path("/owned/second.json"))
    .unwrap();
    assert_eq!(
        second.rendered.parse::<DocumentMut>().unwrap()["model_catalog_json"].as_str(),
        crate::agents::test_absolute_path("/owned/second.json").to_str()
    );
    let record =
        CodexNativeRestore::decode_protected(&second.restore.encode_protected().unwrap()).unwrap();
    assert_eq!(
        restore_codex_native(&second.rendered, &record)
            .unwrap()
            .as_str(),
        original
    );
}

#[test]
fn codex_catalog_user_change_is_not_overwritten_by_restore() {
    let edit = configure("", CodexSelectionTarget::Root)
        .unwrap()
        .with_model_catalog(&crate::agents::test_absolute_path("/owned/catalog.json"))
        .unwrap();
    let mut changed = edit.rendered.parse::<DocumentMut>().unwrap();
    changed["model_catalog_json"] = toml_edit::value(
        crate::agents::test_absolute_path("/user/new.json")
            .to_str()
            .unwrap(),
    );
    assert!(matches!(
        restore_codex_native(&changed.to_string(), &edit.restore),
        Err(CodexNativeError::FieldConflict)
    ));
}

#[test]
fn codex_catalog_relative_path_is_rejected() {
    assert!(matches!(
        configure("", CodexSelectionTarget::Root)
            .unwrap()
            .with_model_catalog(std::path::Path::new("relative.json")),
        Err(CodexNativeError::InvalidIntent)
    ));
}

#[test]
fn codex_catalog_parent_path_is_rejected() {
    assert!(matches!(
        configure("", CodexSelectionTarget::Root)
            .unwrap()
            .with_model_catalog(&crate::agents::test_absolute_path("/owned/../catalog.json")),
        Err(CodexNativeError::InvalidIntent)
    ));
}

#[test]
fn codex_catalog_repeated_attachment_is_rejected() {
    let edit = configure("", CodexSelectionTarget::Root)
        .unwrap()
        .with_model_catalog(&crate::agents::test_absolute_path("/owned/first.json"))
        .unwrap();
    assert!(matches!(
        edit.with_model_catalog(&crate::agents::test_absolute_path("/owned/second.json")),
        Err(CodexNativeError::InvalidIntent)
    ));
}

#[test]
fn codex_native_never_produces_a_config_too_large_for_its_restore_reader() {
    let near_limit = format!("#{}\n", "x".repeat(MAX_BYTES - 12));
    assert!(near_limit.len() < MAX_BYTES);
    assert!(matches!(
        configure(&near_limit, CodexSelectionTarget::Root),
        Err(CodexNativeError::InvalidToml)
    ));
}

#[test]
fn managed_profile_rejects_added_auth_fields_and_headers_but_preserves_them_on_revoke() {
    let edit = configure("", CodexSelectionTarget::Root).unwrap();
    for extra in [
        "[model_providers.hiroute]\nenv_key = 'USER_SECRET'\n",
        "[model_providers.hiroute.http_headers]\nAuthorization = 'user-owned'\n",
    ] {
        let mut current = edit.rendered.parse::<DocumentMut>().unwrap();
        let addition = extra.parse::<DocumentMut>().unwrap();
        if extra.contains("Authorization") {
            current["model_providers"]["hiroute"]["http_headers"]["Authorization"] =
                addition["model_providers"]["hiroute"]["http_headers"]["Authorization"].clone();
        } else {
            current["model_providers"]["hiroute"]["env_key"] =
                addition["model_providers"]["hiroute"]["env_key"].clone();
        }
        let current = current.to_string();
        assert!(!edit.restore.managed_fields_are_applied(&current));
        assert!(matches!(
            reconfigure_codex_native(
                &current,
                &CanonicalDigest::of_bytes(current.as_bytes()),
                &edit.restore,
                CodexSelectionTarget::Root,
                "hiroute",
                "http://127.0.0.1:5837/v1",
                None,
                &AgentAccessGrantMaterial::from_csprng_entropy([4; 32]),
            ),
            Err(CodexNativeError::FieldConflict)
        ));
        let restored = restore_codex_native(&current, &edit.restore).unwrap();
        assert!(!restored.contains("X-HiRoute-Token"));
        assert!(restored.contains(if extra.contains("Authorization") {
            "user-owned"
        } else {
            "USER_SECRET"
        }));
    }
}