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.6 KB
Raw Blame
use super::*;

pub(super) fn prepare(
    client: &LocalControlClient,
    command: &str,
    options: &[String],
) -> Result<Value> {
    match command {
        "routing.preview" => routing(client, options),
        "compute.connection.preview" => compute(client, options),
        "decision.services.apply" => super::decision::prepare(client, options),
        "decision.services.test" => super::decision::test(client, options),
        "agents.connect.preview" | "agents.restore.preview" => {
            settings::prepare(client, command, options)
        }
        _ => Err(error(ErrorCode::InvalidArguments)),
    }
}

fn routing(client: &LocalControlClient, options: &[String]) -> Result<Value> {
    let flags = Flags::parse(
        options,
        &[
            "--plan",
            "--name",
            "--purpose",
            "--mode",
            "--decision",
            "--decision-service",
            "--restore-from",
        ],
        &["--model", "--economy", "--primary"],
        &[],
    )?;
    if let Some(path) = flags.get("--restore-from") {
        // A complete baseline is an alternative to editing individual choices.
        if options.len() != 4 {
            return Err(error(ErrorCode::InvalidArguments));
        }
        return super::plan_restore::prepare(client, flags.required("--plan")?, path);
    }
    if flags.has("--decision") && flags.has("--decision-service") {
        return Err(error(ErrorCode::InvalidArguments));
    }
    if !flags.has("--plan") {
        flags.required("--name")?;
        flags.required("--purpose")?;
        flags.required("--mode")?;
    }
    if flags
        .get("--mode")
        .is_some_and(|v| !matches!(v, "fixed_model" | "smart_saving"))
        || flags.get("--decision").is_some_and(|v| v != "local_rules")
    {
        return Err(error(ErrorCode::InvalidArguments));
    }
    let mut authoring = json!({});
    for (flag, field) in [
        ("--plan", "plan_id"),
        ("--name", "display_name"),
        ("--purpose", "purpose"),
        ("--mode", "mode"),
    ] {
        if let Some(value) = flags.get(flag) {
            authoring[field] = json!(value);
        }
    }
    for (flag, field) in [
        ("--model", "candidates"),
        ("--economy", "economy"),
        ("--primary", "primary"),
    ] {
        if flags.has(flag) {
            authoring[field] = json!(
                flags
                    .all(flag)
                    .iter()
                    .map(|binding| json!({"binding_id":binding,"reasoning":null}))
                    .collect::<Vec<_>>()
            );
        }
    }
    if flags.has("--decision") {
        authoring["classifier"] = json!({"kind":"local_rules"});
    }
    if let Some(selected) = flags.get("--decision-service") {
        let (id, revision) = selected
            .rsplit_once('@')
            .ok_or_else(|| choices(&["--decision-service ID@REVISION"], json!({})))?;
        let revision = revision
            .parse::<u64>()
            .map_err(|_| error(ErrorCode::InvalidArguments))?;
        let services = data(client, "ListDecisionServices", json!({}))?;
        let matches = services["services"]
            .as_array()
            .ok_or_else(|| error(ErrorCode::Internal))?
            .iter()
            .filter(|service| service["id"] == id && service["revision"] == revision)
            .collect::<Vec<_>>();
        let [service] = matches.as_slice() else {
            return Err(choices(&["--decision-service"], services));
        };
        authoring["classifier"] = json!({"kind":"decision_service","service":service});
    }
    let authoring: PlanAuthoringRequestV1 =
        serde_json::from_value(authoring).map_err(|_| error(ErrorCode::InvalidArguments))?;
    let options = data(
        client,
        "GetPlanEditorOptions",
        json!({"authoring":authoring}),
    )?;
    let prepared: PlanAuthoringOptionsV1 = serde_json::from_value(options["authoring"].clone())
        .map_err(|_| {
            choices(
                &["server_supporting_shared_authoring"],
                json!({"action":"update_hiroute"}),
            )
        })?;
    if !prepared.required_choices.is_empty() {
        return Err(choices(&["authoring_choices"], json!(prepared)));
    }
    let mode =
        serde_json::to_value(prepared.editor.mode).map_err(|_| error(ErrorCode::Internal))?;
    if mode == "fixed_model"
        && (flags.has("--economy")
            || flags.has("--primary")
            || flags.has("--decision")
            || flags.has("--decision-service"))
        || mode == "smart_saving" && flags.has("--model")
        || mode != "fixed_model" && mode != "smart_saving"
    {
        return Err(choices(
            &["mode_compatible_choices_or_advanced_request"],
            json!({"mode":mode}),
        ));
    }
    let target = match prepared.plan_id {
        Some(plan_id) => PlanContentTargetV2::Update {
            plan_id,
            expected_head_revision: prepared
                .expected_head_revision
                .ok_or_else(|| error(ErrorCode::Internal))?,
        },
        None => PlanContentTargetV2::Create {
            creation_key: fresh_key()?,
        },
    };
    Ok(json!(PlanContentPreviewRequestV2 {
        change: PlanContentChangeV2 {
            schema: PLAN_CONTENT_CHANGE_SCHEMA_V2.into(),
            target,
            editor: prepared.editor,
            consumed_draft: None,
        }
    }))
}

fn compute(client: &LocalControlClient, options: &[String]) -> Result<Value> {
    let flags = Flags::parse(
        options,
        &["--candidate", "--candidate-revision"],
        &["--model-ref"],
        &["--all-selectable"],
    )?;
    if flags.has("--all-selectable") == flags.has("--model-ref") {
        return Err(choices(&["--all-selectable OR --model-ref"], json!({})));
    }
    let reference = ComputeCandidateRefV2 {
        candidate_ref: flags.required("--candidate")?.into(),
        candidate_revision: flags
            .required("--candidate-revision")?
            .parse()
            .map_err(|_| error(ErrorCode::InvalidArguments))?,
    };
    reference
        .validate_shape()
        .map_err(|_| error(ErrorCode::InvalidArguments))?;
    let options = data(
        client,
        "ListConnectionOptions",
        json!({"candidate":reference}),
    )?;
    let candidate: ComputeCandidateViewV2 = serde_json::from_value(options["candidate"].clone())
        .map_err(|_| error(ErrorCode::Internal))?;
    let selectable = candidate
        .models
        .iter()
        .filter(|model| model.selectable)
        .map(|model| model.model_ref.clone())
        .collect::<Vec<_>>();
    let selected = if flags.has("--all-selectable") {
        selectable.clone()
    } else {
        flags.all("--model-ref").to_vec()
    };
    if selected.is_empty()
        || selected.iter().any(|model| !selectable.contains(model))
        || selected
            .iter()
            .collect::<std::collections::BTreeSet<_>>()
            .len()
            != selected.len()
    {
        return Err(choices(
            &["nonempty_selectable_models"],
            json!({"candidate":candidate.candidate,"models":candidate.models}),
        ));
    }
    let snapshot = data(client, "ListCompute", json!({}))?;
    let request = json!({"change": {
        "schema":COMPUTE_MANAGEMENT_CHANGE_SCHEMA_V2,
        "subject":{"kind":"candidate","candidate":candidate.candidate},
        "expected_revisions":snapshot["revisions"], "selected_model_refs":selected,
        "intent":"save_ready", "validation":candidate.validation
    }});
    serde_json::from_value::<ComputeSavePreviewRequestV2>(request.clone())
        .map_err(|_| error(ErrorCode::Internal))?;
    Ok(request)
}