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.
Rust ai-agentsai-gatewayclaude-codecodexcoding-agentcost-optimizationdeepseekllm-gatewayllm-routerlocal-firstmodel-routingrusttask-routingtauri
use super::*;
use crate::compiler::{AgentPlanCompilerError, compile_agent_plan_v2};
use hiroute_domain::{AgentPlanId, AgentPlanIdentityV1, ModelAlias, PlanEditorStateV2};
pub(super) fn dispatch(
ports: &crate::control::ApplicationPorts,
request: LocalControlRequestV2,
) -> MachineEnvelopeV2<Value> {
let payload: PlanEditorOptionsRequestV1 = match serde_json::from_value(request.payload) {
Ok(value) => value,
Err(_) => return failed(ErrorCode::InvalidArguments, request.request_id),
};
let Some(port) = &ports.routing else {
return failed(ErrorCode::DaemonUnavailable, request.request_id);
};
if payload.rating_items.len() > MAX_RATING_QUERY_ITEMS
|| payload.native_selections.len() > MAX_RATING_QUERY_ITEMS
{
return failed(ErrorCode::InvalidArguments, request.request_id);
}
let result = (|| {
let state = port
.routing_compilation_snapshot(&WorkspaceId::default())
.map_err(map_control_error)?;
if state.facts.candidates.len() > MAX_RATING_QUERY_ITEMS {
return Err(ErrorCode::InvalidArguments);
}
let free_suggestions = if payload.suggest_free {
Some(
port.free_plan_suggestions(
&WorkspaceId::default(),
&payload.requirements,
&payload.native_selections,
RatingSnapshotSelectionV1::Latest,
)
.map_err(map_control_error)?,
)
} else {
None
};
let ratings = if payload.rating_items.is_empty() {
None
} else {
match port.resolve_model_ratings(&ResolveModelRatingsV1 {
snapshot: RatingSnapshotSelectionV1::Latest,
items: payload.rating_items,
}) {
Ok(result) => Some(result),
Err(crate::model_catalog::RatingQueryError::SnapshotUnavailable) => None,
Err(_) => return Err(ErrorCode::InvalidArguments),
}
};
let suggested_alias = payload
.display_name
.as_ref()
.map(|name| {
state
.active_publication
.as_ref()
.map(|p| p.alias_registry.clone())
.unwrap_or_default()
.suggest_alias(name)
.map_err(|_| ErrorCode::InvalidArguments)
})
.transpose()?;
if payload.published_plan.is_some() && payload.editor.is_some() {
return Err(ErrorCode::InvalidArguments);
}
let candidates: Vec<PlanCandidateOptionV1> = state
.facts
.candidates
.iter()
.map(|fact| PlanCandidateOptionV1 {
binding_id: fact.binding.binding_id.clone(),
model_configuration_id: fact.model.model_configuration_id.clone(),
display_name: fact.model.display_name.clone(),
reasoning: fact.reasoning.clone(),
billing_class: fact.binding.billing_class,
routable: fact.is_routable(),
native_ingress_protocols: fact
.protocol_profiles
.iter()
.filter(|p| p.ingress_protocol == p.capability.upstream_protocol)
.map(|p| p.ingress_protocol)
.collect(),
ingress_protocols: fact
.protocol_profiles
.iter()
.map(|p| p.ingress_protocol)
.collect(),
})
.collect();
let authoring = payload
.authoring
.as_ref()
.map(|input| {
let current = if let Some(plan_id) = &input.plan_id {
let client = ports
.client_access
.as_ref()
.ok_or(ErrorCode::DaemonUnavailable)?;
Some(
client
.plan_catalog()
.map_err(map_control_error)?
.plans
.into_iter()
.find(|plan| &plan.agent_plan_id == plan_id)
.ok_or(ErrorCode::ResourceNotFound)?,
)
} else {
None
};
crate::routing::prepare_authoring(input, current.as_ref(), &candidates)
})
.transpose()?;
let editor = payload
.editor
.as_ref()
.or_else(|| authoring.as_ref().map(|value| &value.editor));
let (codex_capabilities, claude_capabilities, context_window) = if let Some(reference) =
&payload.published_plan
{
let publication = state
.active_publication
.as_ref()
.ok_or(ErrorCode::ResourceNotFound)?;
let plan = published_preview_plan(publication, reference)?;
let upper = plan
.body
.materialized
.context_window_upper_bound()
.map_err(|_| ErrorCode::CapabilityDenied)?;
(
Some(
port.codex_client_capability_preview(&plan)
.map_err(map_control_error)?,
),
Some(
port.claude_client_capability_preview(&plan)
.map_err(map_control_error)?,
),
Some(PlanContextWindowPreviewV1 {
maximum_tokens: upper,
default_tokens: upper.min(hiroute_domain::DEFAULT_PLAN_CONTEXT_WINDOW_TOKENS),
}),
)
} else {
(
codex_capabilities(editor, &state.facts, port.as_ref())?,
claude_capabilities(editor, &state.facts, port.as_ref()),
context_window_preview(editor, &state.facts),
)
};
let unavailable_candidate_count = (payload.include_unavailable
&& state.unavailable_candidates.len() > MAX_RATING_QUERY_ITEMS)
.then_some(state.unavailable_candidates.len());
Ok(PlanEditorOptionsV1 {
authoring,
unavailable_candidate_count,
unavailable_candidates: if payload.include_unavailable {
state
.unavailable_candidates
.into_iter()
.take(MAX_RATING_QUERY_ITEMS)
.collect()
} else {
Vec::new()
},
claude_capabilities,
context_window,
suggested_alias,
candidates,
ratings,
free_suggestions,
codex_capabilities,
revisions: state.expected_revisions,
})
})();
match result {
Ok(value) => succeeded(value, request.request_id),
Err(error) => failed(error, request.request_id),
}
}
fn codex_capabilities(
editor: Option<&PlanEditorStateV2>,
facts: &crate::compiler::AgentPlanCompilationFactsV1,
port: &dyn crate::control::RoutingFactsPort,
) -> Result<Option<CodexClientCapabilityPreviewV1>, ErrorCode> {
let Some(editor) = editor else {
return Ok(None);
};
let Ok(configuration) = editor.effective() else {
// Incomplete draft rows are ordinary while editing and do not claim a capability state.
return Ok(None);
};
let identity = AgentPlanIdentityV1 {
agent_plan_id: AgentPlanId::parse("plan/codex-capability-preview")
.map_err(|_| ErrorCode::Internal)?,
model_alias: ModelAlias::parse("hiroute-codex-capability-preview")
.map_err(|_| ErrorCode::Internal)?,
display_name: configuration.display_name.clone(),
purpose: configuration.purpose.clone(),
};
let plan = match compile_agent_plan_v2(identity, 1, &configuration, facts) {
Ok(plan) => plan,
Err(error) => return Ok(Some(compilation_unavailable(&error))),
};
port.codex_client_capability_preview(&plan)
.map(Some)
.map_err(map_control_error)
}
fn context_window_preview(
editor: Option<&PlanEditorStateV2>,
facts: &crate::compiler::AgentPlanCompilationFactsV1,
) -> Option<PlanContextWindowPreviewV1> {
let mut editor = editor?.clone();
// Inspect the capability ceiling even when the custom setting exceeds new candidates.
editor.limits.context_window_tokens = None;
let configuration = editor.effective().ok()?;
let identity = AgentPlanIdentityV1 {
agent_plan_id: AgentPlanId::parse("plan/context-window-preview").ok()?,
model_alias: ModelAlias::parse("hiroute-context-window-preview").ok()?,
display_name: configuration.display_name.clone(),
purpose: configuration.purpose.clone(),
};
let plan = compile_agent_plan_v2(identity, 1, &configuration, facts).ok()?;
let maximum_tokens = plan.body.materialized.context_window_upper_bound().ok()?;
Some(PlanContextWindowPreviewV1 {
maximum_tokens,
default_tokens: maximum_tokens.min(hiroute_domain::DEFAULT_PLAN_CONTEXT_WINDOW_TOKENS),
})
}
fn compilation_unavailable(error: &AgentPlanCompilerError) -> CodexClientCapabilityPreviewV1 {
let binding_id = match error {
AgentPlanCompilerError::UnknownBinding(binding_id)
| AgentPlanCompilerError::CandidateNotRoutable(binding_id)
| AgentPlanCompilerError::CapabilityUnqualified(binding_id) => Some(binding_id.clone()),
_ => None,
};
CodexClientCapabilityPreviewV1::Unavailable {
issues: vec![CodexCapabilityIssueV1 {
kind: CodexCapabilityIssueKindV1::PlanCompilation,
binding_id,
}],
}
}
fn claude_capabilities(
editor: Option<&PlanEditorStateV2>,
facts: &crate::compiler::AgentPlanCompilationFactsV1,
port: &dyn crate::control::RoutingFactsPort,
) -> Option<ClaudeClientCapabilityPreviewV1> {
let editor = editor?;
let unavailable = |reason: &str| {
Some(ClaudeClientCapabilityPreviewV1::Unavailable {
reason: reason.into(),
})
};
let Ok(configuration) = editor.effective() else {
return None;
};
let identity = AgentPlanIdentityV1 {
agent_plan_id: AgentPlanId::parse("plan/claude-capability-preview").ok()?,
model_alias: ModelAlias::parse("hiroute-claude-capability-preview").ok()?,
display_name: configuration.display_name.clone(),
purpose: configuration.purpose.clone(),
};
let Ok(plan) = compile_agent_plan_v2(identity, 1, &configuration, facts) else {
return unavailable("plan_compilation");
};
Some(
port.claude_client_capability_preview(&plan)
.unwrap_or_else(|_| ClaudeClientCapabilityPreviewV1::Unavailable {
reason: "request_capabilities".into(),
}),
)
}
fn published_preview_plan(
publication: &hiroute_domain::GatewayPublicationV1,
reference: &PublishedPlanCapabilityRequestV1,
) -> Result<hiroute_domain::CompiledAgentPlanV1, ErrorCode> {
if !publication
.published_agent_plans()
.map_err(|_| ErrorCode::Internal)?
.iter()
.any(|plan| plan.agent_plan_id == reference.plan_id && plan.active)
{
return Err(ErrorCode::ResourceNotFound);
}
let plan = publication
.plans
.iter()
.find(|plan| plan.agent_plan_id() == &reference.plan_id)
.ok_or(ErrorCode::ResourceNotFound)?;
if plan.body.agent_plan_revision != reference.revision {
return Err(ErrorCode::RevisionConflict);
}
plan.clone().into_current().map_err(|_| ErrorCode::Internal)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::compiler::test_fixtures::{compilation_facts, custom_desired};
use crate::control::{ControlReadError, RoutingCompilationSnapshotV1};
use hiroute_domain::{
AgentPlanStrategyV1, ComplexityClassifierModeV1, FreeEditorV2, PLAN_EDITOR_SCHEMA_V2,
PlanEditorMode, SmartEditorV2, WorkspaceId,
};
use std::sync::atomic::{AtomicUsize, Ordering};
#[derive(Default)]
struct PreviewPort {
calls: AtomicUsize,
}
impl crate::control::RoutingFactsPort for PreviewPort {
fn codex_client_capability_preview(
&self,
_plan: &hiroute_domain::CompiledAgentPlanV1,
) -> Result<CodexClientCapabilityPreviewV1, ControlReadError> {
self.calls.fetch_add(1, Ordering::SeqCst);
Ok(CodexClientCapabilityPreviewV1::Available {
context_window: 64_000,
input_modalities: vec![CodexInputModalityV1::Text],
reasoning: CodexReasoningControlV1::RouteConfiguration,
limitations: Vec::new(),
fixed_limits: vec![CodexFixedCapabilityLimitV1::ParallelToolCallsDisabled],
})
}
fn routing_compilation_snapshot(
&self,
_workspace_id: &WorkspaceId,
) -> Result<RoutingCompilationSnapshotV1, ControlReadError> {
Err(ControlReadError::Unavailable)
}
}
fn editor() -> PlanEditorStateV2 {
let desired = custom_desired();
let AgentPlanStrategyV1::Custom { candidates } = desired.strategy else {
unreachable!()
};
PlanEditorStateV2 {
branch_routing: None,
schema: PLAN_EDITOR_SCHEMA_V2.into(),
display_name: desired.display_name.as_str().to_owned(),
purpose: desired.purpose.as_str().to_owned(),
custom_alias: None,
mode: PlanEditorMode::FixedModel,
candidates,
smart: SmartEditorV2 {
economy: Vec::new(),
primary: Vec::new(),
judgment: Default::default(),
reselect_on_user_message: false,
classifier: ComplexityClassifierModeV1::LocalRules,
complex_keywords: Vec::new(),
},
free: FreeEditorV2 {
candidates: Vec::new(),
primary: Vec::new(),
primary_fallback: false,
},
delegation_enabled: false,
work: None,
requirements: desired.requirements,
limits: desired.limits,
}
}
#[test]
fn claude_deployment_preview_reads_the_published_revision_not_current_candidate_facts() {
let publication = crate::compiler::test_fixtures::compiled_publication(1);
let active = publication
.published_agent_plans()
.unwrap()
.into_iter()
.find(|plan| plan.active)
.unwrap();
let mut reference = PublishedPlanCapabilityRequestV1 {
plan_id: active.agent_plan_id.clone(),
revision: active.agent_plan_revision,
};
let exact = published_preview_plan(&publication, &reference).unwrap();
let original = publication
.plans
.iter()
.find(|plan| plan.agent_plan_id() == &reference.plan_id)
.unwrap()
.clone()
.into_current()
.unwrap();
assert_eq!(exact, original);
// A newer draft or changed model metadata cannot be mistaken for a saved revision.
reference.revision += 1;
assert!(matches!(
published_preview_plan(&publication, &reference),
Err(ErrorCode::RevisionConflict)
));
}
#[test]
fn context_bound_survives_a_custom_value_invalidated_by_candidates() {
let mut value = editor();
value.limits.context_window_tokens = Some(1_050_000);
let bounds = context_window_preview(Some(&value), &compilation_facts()).unwrap();
assert!(bounds.maximum_tokens < 1_050_000);
assert_eq!(bounds.default_tokens, bounds.maximum_tokens.min(272_000));
assert!(matches!(
codex_capabilities(Some(&value), &compilation_facts(), &PreviewPort::default())
.unwrap(),
Some(CodexClientCapabilityPreviewV1::Unavailable { .. })
));
}
#[test]
fn complete_editor_compiles_with_current_facts_before_capability_analysis() {
let port = PreviewPort::default();
let preview = codex_capabilities(Some(&editor()), &compilation_facts(), &port).unwrap();
assert!(matches!(
preview,
Some(CodexClientCapabilityPreviewV1::Available {
context_window: 64_000,
..
})
));
assert_eq!(port.calls.load(Ordering::SeqCst), 1);
}
#[test]
fn incomplete_editor_has_no_premature_capability_warning() {
let port = PreviewPort::default();
let mut editor = editor();
editor.display_name.clear();
assert_eq!(
codex_capabilities(Some(&editor), &compilation_facts(), &port).unwrap(),
None
);
assert_eq!(port.calls.load(Ordering::SeqCst), 0);
}
#[test]
fn compilation_failure_identifies_the_selected_binding_without_calling_integration() {
let port = PreviewPort::default();
let mut editor = editor();
editor.candidates[0].binding_id = "binding/missing".into();
assert_eq!(
codex_capabilities(Some(&editor), &compilation_facts(), &port).unwrap(),
Some(CodexClientCapabilityPreviewV1::Unavailable {
issues: vec![CodexCapabilityIssueV1 {
kind: CodexCapabilityIssueKindV1::PlanCompilation,
binding_id: Some("binding/missing".into()),
}],
})
);
assert_eq!(port.calls.load(Ordering::SeqCst), 0);
}
#[test]
fn missing_routing_service_still_reports_daemon_unavailable() {
let response = crate::ApplicationService::default().dispatch(LocalControlRequestV2 {
schema_version: LOCAL_CONTROL_SCHEMA_V2,
request_id: "options-missing-service".into(),
principal: PrincipalV1::interactive_user(),
operation_id: "GetPlanEditorOptions".into(),
protected_grant: None,
payload: serde_json::json!({"include_unavailable": true}),
});
assert_eq!(response.error.unwrap().code, ErrorCode::DaemonUnavailable);
}
}