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.3 KB
Raw Blame
//! V2 content authoring uses the existing routing preview/apply envelope and protected grant.
use hiroute_domain::*;
use serde::{Deserialize, Serialize};

pub use hiroute_domain::{PUBLICATION_CHECKPOINT_CHANGE_SCHEMA_V1, PublicationCheckpointChangeV1};
pub const PUBLICATION_CHECKPOINT_PREVIEW_SCHEMA_V1: &str =
    "hiroute.publication-checkpoint-preview/v1";
#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PublicationCheckpointPreviewV1 {
    pub schema: String,
    pub change_digest: CanonicalDigest,
    pub expected_revisions: RevisionSetV1,
    pub before_digest: CanonicalDigest,
    pub publication_revision: GatewayPublicationRevision,
}
#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PublicationCheckpointPreviewRequestV1 {
    pub change: PublicationCheckpointChangeV1,
}
#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PublicationCheckpointApplyRequestV1 {
    pub change: PublicationCheckpointChangeV1,
    pub accept_digest: CanonicalDigest,
    pub expected_revisions: RevisionSetV1,
    pub idempotency_key: String,
}

pub const PLAN_CONTENT_CHANGE_SCHEMA_V2: &str = "hiroute.plan-content-change/v2";
pub const PLAN_CONTENT_PREVIEW_SCHEMA_V2: &str = "hiroute.plan-content-preview/v2";

#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(tag = "intent", rename_all = "snake_case", deny_unknown_fields)]
pub enum PlanContentTargetV2 {
    Create {
        creation_key: String,
    },
    Update {
        plan_id: AgentPlanId,
        expected_head_revision: u64,
    },
}
#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PlanDraftRefV1 {
    pub draft_id: String,
    pub revision: u64,
}

#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PlanContentChangeV2 {
    pub schema: String,
    pub target: PlanContentTargetV2,
    pub editor: PlanEditorStateV2,
    pub consumed_draft: Option<PlanDraftRefV1>,
}
#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PlanContentPreviewV2 {
    pub schema: String,
    pub change_digest: CanonicalDigest,
    pub expected_revisions: RevisionSetV1,
    pub alias_registry_digest: CanonicalDigest,
    pub before_head: Option<PlanHeadV1>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub legacy_source: Option<PlanVersionV1>,
    pub plan_head: PlanHeadV1,
    pub plan_version: PlanVersionV1,
    pub consumed_draft: Option<PlanDraftRefV1>,
}
#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PlanContentPreviewRequestV2 {
    pub change: PlanContentChangeV2,
}
#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PlanContentApplyRequestV2 {
    pub change: PlanContentChangeV2,
    pub accept_digest: CanonicalDigest,
    pub expected_revisions: RevisionSetV1,
    pub idempotency_key: String,
    /// Opt-in diagnostic projection; never part of Plan identity or write authorization.
    #[serde(default, skip_serializing_if = "is_false")]
    pub include_model_budget_conflict: bool,
}

fn is_false(value: &bool) -> bool {
    !value
}

/// Ordinary publication confirms the exact editing intent and observed resource versions.
/// Authorization remains backend-held and one-shot; this does not authorize a compiled preview.
pub fn plan_content_confirmation_digest(
    change: &PlanContentChangeV2,
    revisions: &RevisionSetV1,
) -> Result<CanonicalDigest, CanonicalDigestError> {
    CanonicalDigest::of(&(PLAN_CONTENT_CHANGE_SCHEMA_V2, change, revisions))
}

pub const PLAN_LIFECYCLE_CHANGE_SCHEMA_V1: &str = "hiroute.plan-lifecycle-change/v1";
pub const PLAN_LIFECYCLE_PREVIEW_SCHEMA_V1: &str = "hiroute.plan-lifecycle-preview/v1";
#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PlanLifecycleChangeV1 {
    pub schema: String,
    pub plan_id: AgentPlanId,
    pub expected_head_revision: u64,
    pub status: PlanLifecycleV1,
}
#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PlanLifecyclePreviewV1 {
    pub schema: String,
    pub change_digest: CanonicalDigest,
    pub expected_revisions: RevisionSetV1,
    pub before_head: PlanHeadV1,
    pub plan_head: PlanHeadV1,
    pub references_digest: CanonicalDigest,
    pub has_agent_references: bool,
    pub has_version_holds: bool,
    pub no_new_calls: bool,
}
#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PlanLifecyclePreviewRequestV1 {
    pub change: PlanLifecycleChangeV1,
}
#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PlanLifecycleApplyRequestV1 {
    pub change: PlanLifecycleChangeV1,
    pub accept_digest: CanonicalDigest,
    pub expected_revisions: RevisionSetV1,
    pub idempotency_key: String,
}

pub const PLAN_DRAFT_CHANGE_SCHEMA_V1: &str = hiroute_domain::PLAN_DRAFT_CHANGE_SCHEMA_V1;
pub const PLAN_DRAFT_PREVIEW_SCHEMA_V1: &str = "hiroute.plan-draft-preview/v1";
#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PlanDraftPreviewRequestV1 {
    pub change: PlanDraftChangeV1,
}
#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PlanDraftApplyRequestV1 {
    pub change: PlanDraftChangeV1,
    pub accept_digest: CanonicalDigest,
    pub expected_revisions: RevisionSetV1,
    pub idempotency_key: String,
}
#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PlanDraftPreviewV1 {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub legacy_source: Option<PlanVersionV1>,
    pub schema: String,
    pub change_digest: CanonicalDigest,
    pub expected_revisions: RevisionSetV1,
    pub before: Option<PlanDraftV1>,
    pub after: Option<PlanDraftV1>,
}

#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum SuggestionUnavailableReasonV1 {
    NotFree,
    NotRoutable,
    CapabilityUnqualified,
    NativeSelectionRequired,
    NativeSelectionInvalid,
}
#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct FreeSuggestionV1 {
    pub selection: CandidateSelectionV1,
    pub model_configuration_id: String,
    pub exact_native_reasoning: ExactNativeReasoningV1,
    /// None means the rating service has no snapshot; it is never converted to a zero score.
    pub rating: Option<ResolvedModelRatingV1>,
}
#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct FreeSuggestionsV1 {
    pub snapshot_ref: Option<RatingSnapshotRefV1>,
    pub candidates: Vec<FreeSuggestionV1>,
    pub unavailable: std::collections::BTreeMap<String, SuggestionUnavailableReasonV1>,
}

#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PlanCandidateOptionV1 {
    pub binding_id: String,
    pub model_configuration_id: String,
    pub display_name: String,
    pub reasoning: NativeReasoningCapabilityV1,
    pub billing_class: BillingClass,
    pub routable: bool,
    pub ingress_protocols: Vec<UpstreamProtocol>,
    pub native_ingress_protocols: Vec<UpstreamProtocol>,
}

/// Safe local reasons; never carry provider payloads, endpoints or credentials.
#[derive(schemars::JsonSchema, Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum PlanCandidateUnavailableReasonV1 {
    InvalidModelId,
    SourceNotReady,
    ModelNotEligible,
    CatalogMismatch,
    CredentialUnavailable,
    RuntimeUnavailable,
    CapabilityUnavailable,
    InvalidConfiguration,
}

#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PlanUnavailableCandidateV1 {
    pub binding_id: String,
    pub display_name: String,
    pub reason: PlanCandidateUnavailableReasonV1,
}

#[derive(schemars::JsonSchema, Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum CodexInputModalityV1 {
    Text,
    Image,
}

#[derive(schemars::JsonSchema, Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum CodexReasoningControlV1 {
    RouteConfiguration,
}

#[derive(schemars::JsonSchema, Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum CodexCandidateCapabilityLimitKindV1 {
    ContextWindow,
    ImageInput,
}

#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct CodexCandidateCapabilityLimitV1 {
    pub kind: CodexCandidateCapabilityLimitKindV1,
    pub binding_ids: Vec<String>,
}

#[derive(schemars::JsonSchema, Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum CodexFixedCapabilityLimitV1 {
    ParallelToolCallsDisabled,
}

#[derive(schemars::JsonSchema, Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum CodexCapabilityIssueKindV1 {
    PlanCompilation,
    InvalidCompiledPlan,
    ResponsesProtocol,
    RequestCapabilities,
    InstructionRoles,
    ContextInput,
    ContextOutput,
    ContextTotal,
    ReasoningProfile,
    ContextWindow,
}

#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct CodexCapabilityIssueV1 {
    pub kind: CodexCapabilityIssueKindV1,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub binding_id: Option<String>,
}

#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(tag = "state", rename_all = "snake_case", deny_unknown_fields)]
pub enum CodexClientCapabilityPreviewV1 {
    Available {
        context_window: u64,
        input_modalities: Vec<CodexInputModalityV1>,
        reasoning: CodexReasoningControlV1,
        limitations: Vec<CodexCandidateCapabilityLimitV1>,
        fixed_limits: Vec<CodexFixedCapabilityLimitV1>,
    },
    Unavailable {
        issues: Vec<CodexCapabilityIssueV1>,
    },
}

#[derive(schemars::JsonSchema, Clone, Debug, Default, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PlanEditorOptionsRequestV1 {
    /// Opt in so released strict response readers keep their original field set.
    #[serde(default)]
    pub include_unavailable: bool,
    #[serde(default)]
    pub published_plan: Option<PublishedPlanCapabilityRequestV1>,
    #[serde(default)]
    pub display_name: Option<String>,
    #[serde(default)]
    pub requirements: CapabilityRequirementsV1,
    #[serde(default)]
    pub native_selections: std::collections::BTreeMap<String, ReasoningSelectionV1>,
    #[serde(default)]
    pub suggest_free: bool,
    #[serde(default)]
    pub rating_items: Vec<crate::ModelRatingQueryItemV1>,
    #[serde(default)]
    pub editor: Option<PlanEditorStateV2>,
    /// Explicitly requested authoring policy; absent preserves released response bytes.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub authoring: Option<PlanAuthoringRequestV1>,
}
#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PlanEditorOptionsV1 {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub authoring: Option<PlanAuthoringOptionsV1>,
    /// Present only when opted-in explanations are bounded to the first page.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub unavailable_candidate_count: Option<usize>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub unavailable_candidates: Vec<PlanUnavailableCandidateV1>,
    pub claude_capabilities: Option<ClaudeClientCapabilityPreviewV1>,
    pub context_window: Option<PlanContextWindowPreviewV1>,
    pub suggested_alias: Option<ModelAlias>,
    pub candidates: Vec<PlanCandidateOptionV1>,
    pub free_suggestions: Option<FreeSuggestionsV1>,
    pub ratings: Option<crate::ResolveModelRatingsResultV1>,
    pub codex_capabilities: Option<CodexClientCapabilityPreviewV1>,
    pub revisions: RevisionSetV1,
}

/// Meaningful edits to a new or existing Plan. Omitted fields preserve saved settings.
#[derive(schemars::JsonSchema, Clone, Debug, Default, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PlanAuthoringRequestV1 {
    #[serde(default)]
    pub plan_id: Option<AgentPlanId>,
    #[serde(default)]
    pub mode: Option<PlanEditorMode>,
    #[serde(default)]
    pub display_name: Option<String>,
    #[serde(default)]
    pub purpose: Option<String>,
    #[serde(default)]
    pub candidates: Option<Vec<CandidateSelectionV1>>,
    #[serde(default)]
    pub economy: Option<Vec<CandidateSelectionV1>>,
    #[serde(default)]
    pub primary: Option<Vec<CandidateSelectionV1>>,
    #[serde(default)]
    pub classifier: Option<ComplexityClassifierModeV1>,
}

#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PlanAuthoringOptionsV1 {
    pub editor: PlanEditorStateV2,
    pub plan_id: Option<AgentPlanId>,
    pub expected_head_revision: Option<u64>,
    pub required_choices: Vec<PlanAuthoringChoiceV1>,
    pub candidate_defaults: Vec<PlanCandidateDefaultsV1>,
}

#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PlanCandidateDefaultsV1 {
    pub binding_id: String,
    pub economy: Option<ReasoningSelectionV1>,
    pub primary: Option<ReasoningSelectionV1>,
}

#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PlanAuthoringChoiceV1 {
    pub field: String,
    pub reason: PlanAuthoringChoiceReasonV1,
}

#[derive(schemars::JsonSchema, Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum PlanAuthoringChoiceReasonV1 {
    Required,
    CandidateUnavailable,
    ReasoningRequired,
    InvalidSelection,
}

/// Independent capability bound remains visible when a saved custom window becomes invalid.
#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PlanContextWindowPreviewV1 {
    pub maximum_tokens: u64,
    pub default_tokens: u64,
}

#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Serialize)]
#[serde(tag = "state", rename_all = "snake_case", deny_unknown_fields)]
pub enum ClaudeClientCapabilityPreviewV1 {
    Available {
        context_window: u64,
        plan_window: u64,
    },
    Unavailable {
        reason: String,
    },
}

#[derive(schemars::JsonSchema, Clone, Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PublishedPlanCapabilityRequestV1 {
    pub plan_id: hiroute_domain::AgentPlanId,
    pub revision: u64,
}