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.

15.2 KB
Raw Blame
//! V2 independent settings on the existing connect descriptors and protected confirmation flow.
use crate::agent_connection::{
    SettingsConfirmationError, SettingsModelTargetFacts, confirm_agent_settings,
    preview_agent_settings,
};
use crate::{ApplicationService, failed, map_control_error, succeeded};
use hiroute_application_api::{
    AgentCollaborationEffectV2, AgentSettingsApplyV2, AgentSettingsPreviewRequestV2,
    ApplyRequestV1, CHANGE_SPEC_SCHEMA_V1, ErrorCode, LocalControlRequestV2, MachineEnvelopeV2,
};
use serde_json::{Value, json};

pub(crate) fn preview(
    service: &ApplicationService,
    request: LocalControlRequestV2,
) -> MachineEnvelopeV2<Value> {
    if request.protected_grant.is_some() {
        return failed(ErrorCode::CapabilityDenied, request.request_id);
    }
    let payload: AgentSettingsPreviewRequestV2 = match serde_json::from_value(request.payload) {
        Ok(payload) => payload,
        Err(_) => return failed(ErrorCode::InvalidArguments, request.request_id),
    };
    // Restore owns a distinct confirmation and idempotency scope. Keep the descriptor
    // consistent with the journal kind the strict settings reader derives from this spec.
    let restore = request.operation_id == "PreviewAgentConnectionRestore";
    if restore != payload.spec.is_restore_only() {
        return failed(ErrorCode::InvalidArguments, request.request_id);
    }
    let Some(port) = service
        .ports
        .as_ref()
        .and_then(|ports| ports.agent_connection.as_deref())
    else {
        return failed(ErrorCode::DaemonUnavailable, request.request_id);
    };
    let input = match port.settings_facts(&payload.spec) {
        Ok(input) => input,
        Err(error) => return settings_read_failure(error, request.request_id),
    };
    let preview = match preview_agent_settings(payload.spec, &input.facts) {
        Ok(preview) => preview,
        Err(_) => return failed(ErrorCode::InvalidArguments, request.request_id),
    };
    use hiroute_application_api::{
        AgentModelEffectPreviewV2, AgentResidentServicePreviewV2, AgentSettingsPreviewV2,
    };
    let collaboration_effect = match &preview.spec.collaboration {
        hiroute_application_api::AgentFacetIntent::Configure { settings } => {
            Some(AgentCollaborationEffectV2 {
                action: "configure".into(),
                trigger_mode: settings.trigger_mode,
            })
        }
        _ => None,
    };
    let configured =
        |agent_class: &str,
         provider_id: Option<&String>,
         endpoint: &String,
         selection: &hiroute_application_api::AgentModelSelectionV2| {
            AgentModelEffectPreviewV2::Configure {
                agent_class: agent_class.into(),
                provider_id: provider_id.cloned(),
                endpoint: endpoint.clone(),
                selection: Box::new(selection.clone()),
                authentication: "connection_scoped_local_grant".into(),
                native_adapter: (agent_class == "hermes").then(|| hiroute_application_api::AgentNativeAdapterPreviewV1 {
                    resources: "planned".into(), runtime_loading: hiroute_application_api::AgentNativeRuntimeLoadingV1::Unobserved,
                    next_action: hiroute_application_api::AgentNativeAdapterNextActionV1::ReloadPluginsIfRunning,
                }),
                context_windows: (!preview.context_windows.is_empty())
                    .then(|| preview.context_windows.clone()),
                claude_context_window: (!preview.context_windows.is_empty())
                    .then_some(preview.claude_context_window),
            }
        };
    let model_effect = match (
        &preview.spec.model,
        input.model_file.as_ref().map(|file| &file.target),
    ) {
        (
            hiroute_application_api::AgentFacetIntent::Configure { settings },
            Some(SettingsModelTargetFacts::Hermes {
                provider_id,
                endpoint,
                ..
            }),
        ) => configured("hermes", Some(provider_id), endpoint, settings),
        (
            hiroute_application_api::AgentFacetIntent::Configure { settings },
            Some(SettingsModelTargetFacts::Codex {
                provider_id,
                endpoint,
                ..
            }),
        ) => configured("codex", Some(provider_id), endpoint, settings),
        (
            hiroute_application_api::AgentFacetIntent::Configure { settings },
            Some(SettingsModelTargetFacts::Claude(claude)),
        ) => configured("claude", None, &claude.gateway_base_url, settings),
        (
            hiroute_application_api::AgentFacetIntent::Configure { settings },
            Some(SettingsModelTargetFacts::Additional {
                kind,
                provider_id,
                endpoint,
                ..
            }),
        ) => configured(kind.as_str(), Some(provider_id), endpoint, settings),
        (hiroute_application_api::AgentFacetIntent::Restore { restore_point_ref }, Some(_)) => {
            AgentModelEffectPreviewV2::Restore {
                restore_point_ref: restore_point_ref.clone(),
            }
        }
        (hiroute_application_api::AgentFacetIntent::Keep, _) => AgentModelEffectPreviewV2::Keep,
        (_, None) => return failed(ErrorCode::InvalidArguments, request.request_id),
    };
    succeeded(
        AgentSettingsPreviewV2 {
            schema: "hiroute.agent-settings-preview/v2".into(),
            expected_revisions: input.expected_revisions,
            applicable: preview.blockers.is_empty(),
            resident_service: AgentResidentServicePreviewV2 {
                login_item_required: input
                    .facts
                    .model
                    .as_ref()
                    .is_some_and(|model| model.common.login_item_required),
                login_item_removal_required: input
                    .facts
                    .model
                    .as_ref()
                    .is_some_and(|model| model.common.login_item_removal_required),
            },
            collaboration_effect,
            model_effect,
            preview,
        },
        request.request_id,
    )
}

pub(crate) fn apply(
    service: &ApplicationService,
    request: LocalControlRequestV2,
) -> MachineEnvelopeV2<Value> {
    if request.protected_grant.is_some() {
        return failed(ErrorCode::CapabilityDenied, request.request_id);
    }
    if request.operation_id == "ApplyAgentConnectionChange"
        && request.payload.get("schema").is_some()
    {
        let payload: hiroute_application_api::AgentSettingsRetryV1 =
            match serde_json::from_value(request.payload) {
                Ok(value) => value,
                Err(_) => return failed(ErrorCode::InvalidArguments, request.request_id),
            };
        if payload.schema != "hiroute.agent-settings-retry/v1" {
            return failed(ErrorCode::InvalidArguments, request.request_id);
        }
        let Some(port) = service
            .ports
            .as_ref()
            .and_then(|p| p.agent_connection.as_ref())
        else {
            return failed(ErrorCode::DaemonUnavailable, request.request_id);
        };
        return match port.retry_settings_operation(&payload) {
            Ok(operation) => super::accepted_apply(operation, request.request_id),
            Err(error) => failed(map_control_error(error), request.request_id),
        };
    }
    let payload: AgentSettingsApplyV2 = match serde_json::from_value(request.payload) {
        Ok(payload) => payload,
        Err(_) => return failed(ErrorCode::InvalidArguments, request.request_id),
    };
    let restore = request.operation_id == "ApplyAgentConnectionRestore";
    if restore != payload.spec.is_restore_only() {
        return failed(ErrorCode::InvalidArguments, request.request_id);
    }
    let operation_kind = if restore {
        "ApplyAgentConnectionRestore"
    } else {
        "ApplyAgentConnectionChange"
    };
    let Some(ports) = service.ports.as_ref() else {
        return failed(ErrorCode::DaemonUnavailable, request.request_id);
    };
    if let Some(replay) = super::replay_apply(
        ports.control.as_ref(),
        hiroute_application_api::PrincipalKind::InteractiveUser,
        operation_kind,
        &payload.idempotency_key,
        &payload.accept_digest,
        &request.request_id,
    ) {
        return replay;
    }
    let Some(port) = ports.agent_connection.as_ref() else {
        return failed(ErrorCode::DaemonUnavailable, request.request_id);
    };
    let input = match port.settings_facts(&payload.spec) {
        Ok(input) => input,
        Err(error) => return settings_read_failure(error, request.request_id),
    };
    if !input
        .facts
        .model
        .as_ref()
        .is_some_and(|model| model.common.login_item_removal_required)
        && payload.login_item.is_some()
    {
        // New saves do not own startup state; an unsolicited host declaration must not be
        // silently accepted after an older Desktop has changed the system login item.
        return failed(ErrorCode::InvalidArguments, request.request_id);
    }
    if input
        .facts
        .model
        .as_ref()
        .is_some_and(|model| model.common.login_item_removal_required)
        && !payload
            .login_item
            .as_ref()
            .is_some_and(|declaration| declaration.removes_resident_service())
    {
        // Releasing the last managed connection must also release the login item this
        // feature owns; a restore that leaves it registered never completes.
        return failed(ErrorCode::GatewayUnavailable, request.request_id);
    }
    if input.expected_revisions != payload.expected_revisions {
        return failed(ErrorCode::ChangePreviewStale, request.request_id);
    }
    let confirmed = match confirm_agent_settings(payload.clone(), &input.facts) {
        Ok(confirmed) => confirmed,
        Err(error) => return failed(confirmation_error(error), request.request_id),
    };
    let plan = match input.seal_settings(&confirmed) {
        Ok(plan) => plan,
        Err(_) => return failed(ErrorCode::InvalidArguments, request.request_id),
    };
    let apply = ApplyRequestV1 {
        schema_version: CHANGE_SPEC_SCHEMA_V1,
        spec: plan.spec().clone(),
        accept_digest: payload.accept_digest.clone(),
        expected_revisions: payload.expected_revisions.clone(),
        idempotency_key: payload.idempotency_key.clone(),
        apply_capability: None,
    };
    let expected_plan = plan.clone();
    let port = port.clone();
    let admission = if restore {
        crate::PreparedTransactionV1::for_agent_settings_restore(
            apply,
            payload.accept_digest.clone(),
            plan,
        )
    } else {
        crate::PreparedTransactionV1::for_setup(apply, payload.accept_digest.clone(), plan)
    };
    let prepared = match admission {
        Ok(prepared) => prepared.with_revalidation(move || {
            let stale = || crate::TransactionError::ChangePreviewStale;
            let fresh = port.settings_facts(&payload.spec).map_err(|_| stale())?;
            if fresh.expected_revisions != payload.expected_revisions {
                return Err(stale());
            }
            let confirmed = confirm_agent_settings(payload, &fresh.facts).map_err(|_| stale())?;
            if fresh.seal_settings(&confirmed).map_err(|_| stale())? != expected_plan {
                return Err(stale());
            }
            Ok(())
        }),
        Err(error) => return failed(error.error_code(), request.request_id),
    };
    let Some(mutation) = ports.mutation.as_deref() else {
        return failed(ErrorCode::DaemonUnavailable, request.request_id);
    };
    match mutation.apply_local_prepared_change(prepared) {
        Ok(operation) => super::accepted_apply(operation, request.request_id),
        Err(error) => failed(error.error_code(), request.request_id),
    }
}
fn confirmation_error(error: SettingsConfirmationError) -> ErrorCode {
    match error {
        SettingsConfirmationError::Invalid => ErrorCode::InvalidArguments,
        SettingsConfirmationError::Stale => ErrorCode::ChangePreviewStale,
        SettingsConfirmationError::Blocked => ErrorCode::CapabilityDenied,
    }
}

fn settings_read_failure(
    error: crate::control::ControlReadError,
    request_id: String,
) -> MachineEnvelopeV2<Value> {
    let mut response = failed(map_control_error(error), request_id);
    if error == crate::control::ControlReadError::CollaborationRootRequired {
        response
            .error
            .as_mut()
            .expect("failed envelope has an error")
            .message_key = "error.agent_collaboration_root_context_required".into();
        response
            .next_actions
            .push(hiroute_application_api::NextActionV1 {
                command_id: "agents.scan".into(),
                input: json!({}),
                reason_code: "COLLABORATION_ROOT_CONTEXT_REQUIRED".into(),
            });
    }
    response
}

pub(crate) fn status(
    service: &ApplicationService,
    request: LocalControlRequestV2,
) -> MachineEnvelopeV2<Value> {
    if request.protected_grant.is_some() {
        return failed(ErrorCode::CapabilityDenied, request.request_id);
    }
    let payload: hiroute_application_api::AgentSettingsStatusRequestV2 =
        match serde_json::from_value::<hiroute_application_api::AgentSettingsStatusRequestV2>(
            request.payload,
        ) {
            Ok(payload)
                if payload.schema_version == hiroute_application_api::AGENT_SETTINGS_SCHEMA_V2
                    && payload
                        .effective
                        .as_ref()
                        .is_none_or(|effective| effective.valid()) =>
            {
                payload
            }
            _ => return failed(ErrorCode::InvalidArguments, request.request_id),
        };
    let Some(port) = service
        .ports
        .as_ref()
        .and_then(|ports| ports.agent_connection.as_deref())
    else {
        return failed(ErrorCode::DaemonUnavailable, request.request_id);
    };
    match port.settings_status(&payload) {
        Ok(result) => succeeded(result, request.request_id),
        Err(error) => failed(map_control_error(error), request.request_id),
    }
}

/// Read-only draft recovery. The ordinary settings preview must still admit every effect.
pub(crate) fn previous_routing(
    service: &ApplicationService,
    request: LocalControlRequestV2,
) -> MachineEnvelopeV2<Value> {
    if request.protected_grant.is_some() {
        return failed(ErrorCode::CapabilityDenied, request.request_id);
    }
    let query: hiroute_application_api::AgentPreviousRoutingQueryV1 =
        match serde_json::from_value(request.payload) {
            Ok(query) => query,
            Err(_) => return failed(ErrorCode::InvalidArguments, request.request_id),
        };
    let Some(ports) = &service.ports else {
        return failed(ErrorCode::DaemonUnavailable, request.request_id);
    };
    let Some(connection) = ports.agent_connection.as_deref() else {
        return failed(ErrorCode::DaemonUnavailable, request.request_id);
    };
    match crate::agent_connection::preview_previous_routing(
        connection,
        ports.control.as_ref(),
        &query,
    ) {
        Ok(preview) => succeeded(preview, request.request_id),
        Err(error) => failed(map_control_error(error), request.request_id),
    }
}