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::*;
use serde_json::json;

fn spec(model: Value, collaboration: Value) -> ChangeSpecV1 {
    ChangeSpecV1 {
        schema_version: crate::CHANGE_SPEC_SCHEMA_V1,
        command_id: AgentConnectionTransactionKindV1::Settings
            .command_id()
            .into(),
        resource_id: Some("agent-context/test".into()),
        desired_state: json!({
            "schema_version": {"major":2,"minor":0},
            "context_id":"agent-context/test",
            "model":model, "collaboration":collaboration,
        }),
    }
}
fn control(spec: &ChangeSpecV1, file_change: bool) -> AgentConnectionControlIntentV1 {
    AgentConnectionControlIntentV1::from_settings_planner(
        AgentConnectionTransactionSubjectV1::from_registered_profile(
            "agent.codex",
            "default",
            "codex.profile.v1",
        )
        .unwrap(),
        spec,
        file_change,
        &json!({"revision":1}),
    )
    .unwrap()
}
fn effects(
    control: &AgentConnectionControlIntentV1,
    roles: &[AgentConnectionEffectRoleV1],
) -> Vec<ExternalEffectIntentV1> {
    roles
        .iter()
        .map(|role| {
            ExternalEffectIntentV1::from_agent_connection_planner(
                control,
                *role,
                None,
                &json!({"content_digest":CanonicalDigest::of_bytes(b"fixture"), "context_id":"agent-context/test", "action":"install"}),
                0o644,
            )
            .unwrap()
        })
        .collect()
}
fn rebuild(
    plan: &TransactionPlanV1,
    effects: Vec<ExternalEffectIntentV1>,
) -> Result<TransactionPlanV1, OperationValidationError> {
    // The journal decoder uses this same registered seam after decoding protected durable input.
    TransactionPlanV1::from_registered_typed_planner(
        plan.spec().clone(),
        plan.control().clone(),
        None,
        vec![],
        vec![],
        effects,
    )
}

#[test]
fn claude_settings_target_is_the_native_user_configuration() {
    let spec = spec(
        json!({"intent":"keep"}),
        json!({"intent":"configure","settings":{"trigger_mode":"explicit"}}),
    );
    let subject = AgentConnectionTransactionSubjectV1::from_registered_profile(
        "agent_claude_default",
        "claude-messages-v1",
        "builtin/claude-messages/v1",
    )
    .unwrap();
    let role = AgentConnectionEffectRoleV1::ManagedConfiguration;
    let native_target = role.target_for(&subject).unwrap();
    let settings_target = role.settings_target_for(&subject).unwrap();
    assert_eq!(native_target, settings_target);
    let control = AgentConnectionControlIntentV1::from_settings_planner(
        subject,
        &spec,
        true,
        &json!({"revision": 1}),
    )
    .unwrap();
    let intent = ExternalEffectIntentV1::from_agent_connection_planner(
        &control,
        role,
        None,
        &json!({"context_id": "agent-context/test"}),
        0o600,
    )
    .unwrap();
    assert_eq!(intent.target(), settings_target);
    assert!(
        ExternalEffectIntentV1::from_registered_adapter(
            intent.effect_id(),
            intent.kind(),
            format!("{native_target}/launch-snapshot"),
            None,
            intent.desired().clone(),
            intent.desired_mode(),
            intent.sensitive(),
        )
        .is_err()
    );
}

#[test]
fn token_action_requires_model_configure_and_exact_protected_input_slot() {
    let invalid = ChangeSpecV1 {
        desired_state: json!({
            "schema_version": {"major": 2, "minor": 0},
            "context_id": "agent-context/test",
            "model": {"intent": "keep"},
            "collaboration": {"intent": "configure", "settings": {"trigger_mode": "explicit"}},
            "access_token": {"intent": "regenerate"},
        }),
        ..spec(
            json!({"intent":"keep"}),
            json!({"intent":"configure","settings":{"trigger_mode":"explicit"}}),
        )
    };
    assert!(decode_spec(&invalid).is_err());
    let mut configured = model_spec(codex_selection());
    configured.desired_state["access_token"] =
        json!({"intent":"set","input_slot":"candidate/native/agent-token-one"});
    let settings = decode_spec(&configured).unwrap();
    assert!(matches!(
        settings.access_token,
        AgentAccessTokenIntentV1::Set { .. }
    ));
    configured.desired_state["access_token"] = json!({"intent":"set","input_slot":"../other"});
    assert!(decode_spec(&configured).is_err());
}

#[test]
fn settings_catalog_target_is_bound_to_payload_digest() {
    let spec = model_spec(codex_selection());
    let control = control(&spec, false);
    let make = |content: &str| {
        ExternalEffectIntentV1::from_agent_connection_planner(
            &control,
            AgentConnectionEffectRoleV1::ModelCatalog,
            None,
            &json!({"content_digest": CanonicalDigest::of_bytes(content.as_bytes())}),
            0o600,
        )
        .unwrap()
    };
    let first = make("first");
    let second = make("second");
    assert_ne!(first.target(), second.target());
    assert_eq!(first.target(), make("first").target());
    assert!(
        ExternalEffectIntentV1::from_registered_adapter(
            first.effect_id(),
            first.kind(),
            second.target(),
            None,
            first.desired().clone(),
            first.desired_mode(),
            first.sensitive(),
        )
        .is_err()
    );
}

#[test]
fn skill_only_seals_and_reconstructs_without_model_effects() {
    let spec = spec(
        json!({"intent":"keep"}),
        json!({"intent":"configure","settings":{"trigger_mode":"explicit"}}),
    );
    let control = control(&spec, true);
    let plan = TransactionPlanV1::from_agent_connection_planner(
        spec,
        control.clone(),
        effects(&control, &[AgentConnectionEffectRoleV1::RoutingSkill]),
    )
    .unwrap();
    let reconstructed = rebuild(&plan, plan.external().to_vec()).unwrap();
    assert_eq!(
        serde_json::to_value(&plan).unwrap(),
        serde_json::to_value(reconstructed).unwrap()
    );
    assert!(plan.agent_access_grants().is_empty());
    assert!(plan.agent_connection_projection().unwrap().is_none());
    assert!(rebuild(&plan, vec![]).is_err());
    assert!(
        rebuild(
            &plan,
            effects(
                &control,
                &[
                    AgentConnectionEffectRoleV1::RoutingSkill,
                    AgentConnectionEffectRoleV1::ManagedConfiguration,
                    AgentConnectionEffectRoleV1::GrantScopedPublication,
                ]
            )
        )
        .is_err()
    );
    let mut foreign = control.clone();
    foreign.subject.profile_id = "other".into();
    assert!(
        rebuild(
            &plan,
            effects(&foreign, &[AgentConnectionEffectRoleV1::RoutingSkill])
        )
        .is_err()
    );
    for payload in [
        json!({"context_id":"agent-context/other", "action":"install"}),
        json!({"context_id":"agent-context/test", "action":"remove"}),
    ] {
        let wrong = ExternalEffectIntentV1::from_agent_connection_planner(
            &control,
            AgentConnectionEffectRoleV1::RoutingSkill,
            None,
            &payload,
            0o644,
        )
        .unwrap();
        assert!(rebuild(&plan, vec![wrong]).is_err());
    }
}

#[test]
fn shared_skill_reference_change_has_no_file_and_cannot_add_one_on_recovery() {
    let spec = spec(
        json!({"intent":"keep"}),
        json!({"intent":"restore","restore_point_ref":"restore/context"}),
    );
    let control = control(&spec, false);
    let plan =
        TransactionPlanV1::from_agent_connection_planner(spec, control.clone(), vec![]).unwrap();
    assert!(rebuild(&plan, vec![]).is_ok());
    assert!(
        rebuild(
            &plan,
            vec![
                ExternalEffectIntentV1::from_agent_connection_planner(
                    &control,
                    AgentConnectionEffectRoleV1::RoutingSkill,
                    None,
                    &json!({"context_id":"agent-context/test", "action":"remove"}),
                    0o644,
                )
                .unwrap()
            ]
        )
        .is_err()
    );
}

#[test]
fn model_restore_requires_exact_revoke_and_both_model_effects() {
    let spec = spec(
        json!({"intent":"restore","restore_point_ref":"restore/model"}),
        json!({"intent":"keep"}),
    );
    let control = control(&spec, false);
    let external = effects(
        &control,
        &[
            AgentConnectionEffectRoleV1::GrantScopedPublication,
            AgentConnectionEffectRoleV1::ManagedConfiguration,
        ],
    );
    assert!(
        TransactionPlanV1::from_agent_connection_planner(
            spec.clone(),
            control.clone(),
            external.clone()
        )
        .is_err()
    );
    let grant = AgentAccessGrantMutationV1::revoke(
        "principal/local-owner",
        "agent-connection/agent-context/test",
        1,
    )
    .unwrap();
    let plan = TransactionPlanV1::from_agent_connection_planner_with_agent_access_grants(
        spec.clone(),
        control.clone(),
        vec![grant.clone()],
        external,
    )
    .unwrap();
    assert_eq!(
        rebuild(&plan, plan.external().to_vec())
            .unwrap()
            .agent_access_grants(),
        [grant]
    );
    assert!(rebuild(&plan, vec![plan.external()[0].clone()]).is_err());
    let wrong =
        AgentAccessGrantMutationV1::revoke("principal/local-owner", "agent-connection/other", 1)
            .unwrap();
    assert!(
        TransactionPlanV1::from_agent_connection_planner_with_agent_access_grants(
            spec,
            control,
            vec![wrong],
            plan.external().to_vec(),
        )
        .is_err()
    );
}

#[test]
fn independent_spec_rejects_noop_cross_context_unknown_schema_and_raw_dsl() {
    let noop = spec(json!({"intent":"keep"}), json!({"intent":"keep"}));
    assert!(decode_spec(&noop).is_err());
    let valid = spec(
        json!({"intent":"keep"}),
        json!({"intent":"configure","settings":{"trigger_mode":"explicit"}}),
    );
    let mut cross_context = valid.clone();
    cross_context.resource_id = Some("agent-context/other".into());
    assert!(decode_spec(&cross_context).is_err());
    let mut schema = valid.clone();
    schema.desired_state["schema_version"]["major"] = json!(1);
    assert!(decode_spec(&schema).is_err());
    let mut injected = valid;
    injected.desired_state["external_intent"] = json!({"target":"arbitrary-file"});
    assert!(decode_spec(&injected).is_err());
}

fn model_spec(settings: Value) -> ChangeSpecV1 {
    spec(
        json!({"intent":"configure", "settings":settings}),
        json!({"intent":"keep"}),
    )
}

fn codex_selection() -> Value {
    json!({
        "mode":"codex_default",
        "native_model_mode":"preserve_available",
        "fixed_models":[{"client_model_id":"Vendor/Model.V1[1m]", "candidate":{"binding_id":"binding/native"}}],
        "allowed_plan_ids":[],
        "default_selection":{"kind":"preserve_native"}
    })
}

#[test]
fn codex_fixed_selection_preserves_native_name_and_implicit_default() {
    let selection = codex_selection();
    let decoded = decode_spec(&model_spec(selection.clone())).unwrap();
    let AgentFacetIntent::Configure { settings } = decoded.model else {
        panic!("configure");
    };
    assert_eq!(serde_json::to_value(settings).unwrap(), selection);
    let mut legacy = selection;
    legacy["surfaces"] = json!(["codex_cli"]);
    assert!(decode_spec(&model_spec(legacy)).is_err());
}

#[test]
fn model_selection_rejects_empty_routes_and_uncovered_default() {
    let valid = codex_selection();
    for (field, value) in [
        ("fixed_models", json!([])),
        (
            "default_selection",
            json!({"kind":"fixed_model","client_model_id":"unknown"}),
        ),
        (
            "default_selection",
            json!({"kind":"plan","plan_id":"plan_unknown"}),
        ),
    ] {
        let mut selection = valid.clone();
        selection[field] = value;
        assert!(decode_spec(&model_spec(selection)).is_err(), "{field}");
    }
    let mut explicit = valid;
    explicit["default_selection"] =
        json!({"kind":"fixed_model","client_model_id":"Vendor/Model.V1[1m]"});
    assert!(decode_spec(&model_spec(explicit)).is_ok());
}

#[test]
fn fixed_names_reject_duplicates_and_header_control_characters() {
    for name in ["", "bad\0name", "bad\rname", "bad\nname"] {
        let mut selection = codex_selection();
        selection["fixed_models"][0]["client_model_id"] = json!(name);
        assert!(decode_spec(&model_spec(selection)).is_err());
    }
    let mut selection = codex_selection();
    let first = selection["fixed_models"][0].clone();
    selection["fixed_models"]
        .as_array_mut()
        .unwrap()
        .push(first);
    assert!(decode_spec(&model_spec(selection)).is_err());
}

#[test]
fn claude_three_presets_derive_one_scope_and_reject_extra_permissions() {
    let selection = json!({
        "mode":"claude_launcher",
        "surfaces":["claude_cli"],
        "fixed_models":[],
        "preset_mappings":{
            "opus":{"kind":"plan","plan_id":"plan_shared"},
            "sonnet":{"kind":"plan","plan_id":"plan_shared"},
            "haiku":{"kind":"plan","plan_id":"plan_shared"}
        }
    });
    let decoded = decode_spec(&model_spec(selection.clone())).unwrap();
    let AgentFacetIntent::Configure { settings } = decoded.model else {
        panic!("configure");
    };
    assert_eq!(settings.allowed_plan_ids().len(), 1);
    let mut fourth = selection.clone();
    fourth["preset_mappings"]["small_fast"] = json!({"kind":"preserve_native"});
    assert!(decode_spec(&model_spec(fourth)).is_err());
    for field in ["allowed_plan_ids", "default_selection"] {
        let mut extra = selection.clone();
        extra[field] = json!([]);
        assert!(decode_spec(&model_spec(extra)).is_err());
    }
    let mut missing = selection;
    missing["preset_mappings"]
        .as_object_mut()
        .unwrap()
        .remove("haiku");
    assert!(decode_spec(&model_spec(missing)).is_err());
}

#[test]
fn codex_plan_scope_has_no_legacy_thirty_two_item_limit() {
    let mut selection = codex_selection();
    selection["fixed_models"] = json!([]);
    selection["allowed_plan_ids"] = json!((0..33).map(|i| format!("plan_{i}")).collect::<Vec<_>>());
    selection["default_selection"] = json!({"kind":"plan","plan_id":"plan_0"});
    assert!(decode_spec(&model_spec(selection)).is_ok());
    assert!(
        decode_spec(&model_spec(json!({
            "default_plan_id":"plan_0", "allowed_plan_ids":["plan_0"]
        })))
        .is_err()
    );
}