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.

11.6 KB
Raw Blame
//! Non-secret additive Qoder model effects, bound to one settings Operation.
use hiroute_domain::{
    AdditionalAgentModelV1, AgentConnectionControlIntentV1, AgentConnectionEffectRoleV1,
    AgentConnectionTransactionKindV1, AgentFacetIntent, AgentKindV1, AgentModelGrantV2,
    AgentModelRouteV2, AgentModelSelectionV2, AgentOperationRead, AgentSettingsSpecV2,
    CanonicalDigest, ExternalEffectIntentV1, OperationId, OperationValidationError, PortError,
    PortErrorCode, PortResult,
};
use serde::{Deserialize, Serialize};

const QODER_SCHEMA: &str = "hiroute.settings-qoder-model-file/v1";
const PI_SCHEMA: &str = "hiroute.settings-pi-model-file/v1";

pub fn additional_model_kind(intent: &ExternalEffectIntentV1) -> PortResult<AgentKindV1> {
    match intent.desired()["subject"]["agent_id"].as_str() {
        Some("agent_qoder_default") => Ok(AgentKindV1::Qoder),
        Some("agent_pi_default") => Ok(AgentKindV1::Pi),
        Some("agent_dsh_default") => Ok(AgentKindV1::DeepseekHarness),
        Some("agent_opencode_default") => Ok(AgentKindV1::OpenCode),
        _ => Err(invalid()),
    }
}
fn schema(kind: AgentKindV1) -> &'static str {
    match kind {
        AgentKindV1::Pi => PI_SCHEMA,
        AgentKindV1::DeepseekHarness => "hiroute.settings-dsh-model-file/v1",
        AgentKindV1::OpenCode => "hiroute.settings-opencode-model-file/v1",
        _ => QODER_SCHEMA,
    }
}

#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(tag = "action", rename_all = "snake_case", deny_unknown_fields)]
pub enum AdditionalModelFileAction {
    Configure {
        previous_operation: Option<OperationId>,
        provider_id: String,
        endpoint: String,
        models: Vec<AdditionalAgentModelV1>,
    },
    Restore {
        original_operation: OperationId,
    },
}

#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct AdditionalModelFilePayload {
    schema: String,
    pub context_id: String,
    pub expected_content: CanonicalDigest,
    pub change: AdditionalModelFileAction,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub pi_settings_content: Option<CanonicalDigest>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub additional_dependencies: Option<CanonicalDigest>,
}

/// A stable, context-owned namespace. It never adopts an existing unowned provider.
pub fn additional_model_provider_id(context_id: &str) -> String {
    let digest = CanonicalDigest::of_bytes(context_id.as_bytes());
    format!("hiroute-main-{}", &digest.as_str()[7..])
}

pub fn settings_additional_model_file_intent(
    control: &AgentConnectionControlIntentV1,
    context_id: &str,
    expected_content: CanonicalDigest,
    before_fingerprint: Option<CanonicalDigest>,
    change: AdditionalModelFileAction,
    pi_settings_content: Option<CanonicalDigest>,
    additional_dependencies: Option<CanonicalDigest>,
) -> Result<ExternalEffectIntentV1, OperationValidationError> {
    if control.transaction() != AgentConnectionTransactionKindV1::Settings {
        return Err(OperationValidationError::UnregisteredEffectPlan);
    }
    let payload = AdditionalModelFilePayload {
        schema: schema(
            if control.subject().agent_id() == "agent_opencode_default" {
                AgentKindV1::OpenCode
            } else if control.subject().agent_id() == "agent_dsh_default" {
                AgentKindV1::DeepseekHarness
            } else if control.subject().agent_id() == "agent_pi_default" {
                AgentKindV1::Pi
            } else {
                AgentKindV1::Qoder
            },
        )
        .into(),
        context_id: context_id.into(),
        expected_content,
        change,
        pi_settings_content,
        additional_dependencies,
    };
    let intent = ExternalEffectIntentV1::from_agent_connection_planner(
        control,
        AgentConnectionEffectRoleV1::ManagedConfiguration,
        before_fingerprint,
        &payload,
        0o600,
    )?;
    decode_settings_additional_model_file(&intent)
        .map_err(|_| OperationValidationError::UnregisteredEffectPlan)?;
    Ok(intent)
}

pub fn decode_settings_additional_model_file(
    intent: &ExternalEffectIntentV1,
) -> PortResult<AdditionalModelFilePayload> {
    ExternalEffectIntentV1::from_registered_adapter(
        intent.effect_id(),
        intent.kind(),
        intent.target(),
        intent.before_fingerprint().cloned(),
        intent.desired().clone(),
        intent.desired_mode(),
        intent.sensitive(),
    )
    .map_err(|_| invalid())?;
    let value = intent.desired();
    let kind = additional_model_kind(intent)?;
    let (agent, profile, integration) = match kind {
        AgentKindV1::OpenCode => (
            "agent_opencode_default",
            "opencode-responses-v1",
            "builtin/opencode-responses/v1",
        ),
        AgentKindV1::DeepseekHarness => (
            "agent_dsh_default",
            "dsh-responses-v1",
            "builtin/dsh-responses/v1",
        ),
        AgentKindV1::Pi => (
            "agent_pi_default",
            "pi-responses-v1",
            "builtin/pi-responses/v1",
        ),
        _ => (
            "agent_qoder_default",
            "qoder-collaboration-v1",
            "builtin/qoder-collaboration/v1",
        ),
    };
    if intent.effect_id() != "agent-connection-managed-configuration"
        || intent.desired_mode() != 0o600
        || value["transaction"] != "settings"
        || value["subject"]["agent_id"] != agent
        || value["subject"]["profile_id"] != profile
        || value["subject"]["integration_profile_ref"] != integration
    {
        return Err(invalid());
    }
    let payload: AdditionalModelFilePayload =
        serde_json::from_value(value["payload"].clone()).map_err(|_| invalid())?;
    if payload.schema != schema(kind)
        || (kind == AgentKindV1::Pi) != payload.pi_settings_content.is_some()
        || (kind == AgentKindV1::OpenCode) != payload.additional_dependencies.is_some()
        || !super::settings::identity(&payload.context_id)
    {
        return Err(invalid());
    }
    match &payload.change {
        AdditionalModelFileAction::Configure {
            provider_id,
            endpoint,
            models,
            ..
        } => {
            if provider_id != &additional_model_provider_id(&payload.context_id)
                || !local_endpoint(endpoint, kind)
                || models.is_empty()
                || models.len() > 256
                || models.iter().any(|model| {
                    (if matches!(
                        kind,
                        AgentKindV1::Pi | AgentKindV1::DeepseekHarness | AgentKindV1::OpenCode
                    ) {
                        model.validate_pi()
                    } else {
                        model.validate()
                    })
                    .is_err()
                })
                || models.windows(2).any(|pair| pair[0].alias >= pair[1].alias)
            {
                return Err(invalid());
            }
        }
        AdditionalModelFileAction::Restore { .. } => {}
    }
    Ok(payload)
}

pub fn settings_additional_model_file_for_operation(
    operation: &(impl AgentOperationRead + ?Sized),
    intent: &ExternalEffectIntentV1,
) -> PortResult<AdditionalModelFilePayload> {
    let payload = decode_settings_additional_model_file(intent)?;
    let spec: AgentSettingsSpecV2 =
        serde_json::from_value(operation.agent_input().spec.desired_state.clone())
            .map_err(|_| invalid())?;
    if operation.agent_input().spec.command_id != "agents.settings.apply"
        || spec.context_id != payload.context_id
        || !operation.agent_input().external.contains(intent)
        || spec.restore_native_model.is_some()
    {
        return Err(invalid());
    }
    let state = &operation.agent_input().control["payload"]["state"];
    if state["accept_digest"]
        != serde_json::to_value(operation.accepted_digest()).map_err(|_| invalid())?
    {
        return Err(invalid());
    }
    let kind = additional_model_kind(intent)?;
    match (&spec.model, &payload.change) {
        (
            AgentFacetIntent::Configure {
                settings:
                    AgentModelSelectionV2::QoderAdditional {
                        allowed_plan_ids, ..
                    }
                    | AgentModelSelectionV2::PiAdditional {
                        allowed_plan_ids, ..
                    }
                    | AgentModelSelectionV2::DshAdditional {
                        allowed_plan_ids, ..
                    }
                    | AgentModelSelectionV2::OpenCodeAdditional {
                        allowed_plan_ids, ..
                    },
            },
            AdditionalModelFileAction::Configure {
                previous_operation,
                models,
                ..
            },
        ) => {
            if matches!(
                &spec.model,
                AgentFacetIntent::Configure {
                    settings: AgentModelSelectionV2::PiAdditional { .. }
                }
            ) != (kind == AgentKindV1::Pi)
                || matches!(
                    &spec.model,
                    AgentFacetIntent::Configure {
                        settings: AgentModelSelectionV2::DshAdditional { .. }
                    }
                ) != (kind == AgentKindV1::DeepseekHarness)
                || matches!(
                    &spec.model,
                    AgentFacetIntent::Configure {
                        settings: AgentModelSelectionV2::OpenCodeAdditional { .. }
                    }
                ) != (kind == AgentKindV1::OpenCode)
            {
                return Err(invalid());
            }
            let grant: AgentModelGrantV2 =
                serde_json::from_value(state["model_grant"].clone()).map_err(|_| invalid())?;
            let [mutation] = operation.agent_input().grants else {
                return Err(invalid());
            };
            let scope = mutation.desired_scope().ok_or_else(invalid)?;
            if scope.model_grant() != &grant
                || previous_operation.as_ref() == Some(operation.operation_id())
                || models.len() != grant.routes.len() || models.len() != allowed_plan_ids.len()
                || !models.iter().all(|model| matches!(grant.routes.get(&model.alias), Some(AgentModelRouteV2::Plan { plan_id, alias, .. }) if allowed_plan_ids.contains(plan_id) && alias.as_str() == model.alias && grant.protocol_for(&model.alias) == model.protocol))
            { return Err(invalid()); }
        }
        (
            AgentFacetIntent::Restore { restore_point_ref },
            AdditionalModelFileAction::Restore { original_operation },
        ) if original_operation != operation.operation_id()
            && *restore_point_ref == super::codex_model_restore_point_ref(original_operation) => {}
        _ => return Err(invalid()),
    }
    Ok(payload)
}

fn local_endpoint(value: &str, kind: AgentKindV1) -> bool {
    value
        .strip_prefix("http://127.0.0.1:")
        .or_else(|| value.strip_prefix("http://[::1]:"))
        .and_then(|rest| {
            rest.strip_suffix(
                if matches!(
                    kind,
                    AgentKindV1::Pi | AgentKindV1::DeepseekHarness | AgentKindV1::OpenCode
                ) {
                    "/v1"
                } else {
                    hiroute_domain::QODER_MODEL_BASE_PATH
                },
            )
        })
        .is_some_and(|port| {
            !port.is_empty()
                && port.bytes().all(|b| b.is_ascii_digit())
                && port.parse::<u16>().is_ok_and(|p| p != 0)
        })
}
fn invalid() -> PortError {
    PortError::new(PortErrorCode::InvalidData, "qoder.settings.intent")
}