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
//! Public daemon-instance Worker admission over the owner-only local transport.
use std::collections::BTreeSet;
use std::sync::Arc;
use hiroute_application::delegation::admission::DelegationAdmission;
use hiroute_application::publication::admission::{AdmissionAction, AdmissionSubject};
use hiroute_application::publication::versions::ExactPlanVersionPort;
use hiroute_application_api::{
DELEGATION_ACCEPTED_SCHEMA_V1, DelegationAcceptedV1, WorkerExecRequestV1, derive_worker_title,
normalize_worker_title,
};
use hiroute_domain::delegation::{
DELEGATION_RUN_CONFIGURATION_VERSION_V1, DelegationAcceptanceV1, DelegationErrorV1,
DelegationPlanBindingV1, DelegationRunConfigurationV1, DelegationRuntimePort,
DelegationTaskTitleSourceV1, DelegationTaskTitleV1, DelegationTaskV1, RunProgressV1,
};
use hiroute_domain::{
AgentPlanId, CanonicalDigest, PlanExecutionRef, PlanLifecycleV1, PlanVersionError,
PublicationRepositoryPort, VersionOwnerRefV1, VersionReservationV1, WorkspaceId,
};
use hiroute_observation::managed_text::ManagedTextScope;
use super::{
LocalControlAdapter,
delegation_task_queries::authorize,
delegation_tasks::{
canonical_workspace_with_path, current_time_ms, deadline_seconds, run_owner,
},
};
pub(super) struct CurrentPlan {
pub(super) binding: DelegationPlanBindingV1,
pub(super) reference: PlanExecutionRef,
pub(super) runtime_blocker: Option<&'static str>,
}
/// Internal instance partition. It is derived by the daemon and never comes from a Worker DTO.
#[derive(Clone)]
pub(super) struct DelegationCallerContext {
workspace_id: WorkspaceId,
}
impl DelegationCallerContext {
pub(super) fn workspace_id(&self) -> &WorkspaceId {
&self.workspace_id
}
}
impl LocalControlAdapter {
pub(super) fn worker_instance(&self) -> DelegationCallerContext {
DelegationCallerContext {
workspace_id: WorkspaceId::default(),
}
}
pub(super) fn exec_worker(
&self,
request: &WorkerExecRequestV1,
) -> Result<DelegationAcceptedV1, DelegationErrorV1> {
if !request.valid() {
return Err(DelegationErrorV1::InvalidArguments);
}
let instance = self.worker_instance();
let workspace = instance.workspace_id().clone();
if let Some(existing) = DelegationRuntimePort::find_submission(
self,
&workspace,
false,
&request.submission_key,
)? {
let task = DelegationRuntimePort::task(self, &workspace, &existing.task_id)?
.ok_or(DelegationErrorV1::StorageUnavailable)?;
authorize(&instance, &task, &existing)?;
existing.configuration.validate_for(&existing)?;
let canonical_workspace_path = replay_workspace_path(
&request.cwd,
&existing.configuration.canonical_workspace_path,
)?;
let request_digest = keyed_worker_request_digest(
&self.delegation_digest_authority,
request,
&canonical_workspace_path,
)?;
let title = self
.task_content_projection(&task, current_time_ms()?)
.title;
return replay_or_conflict(existing, &request_digest, title);
}
let now_ms = current_time_ms()?;
let (workspace_identity, canonical_workspace_path) =
canonical_workspace_with_path(&request.cwd)?;
let execution = request.execution(workspace_identity.root_identity.clone());
let request_digest = keyed_worker_request_digest(
&self.delegation_digest_authority,
request,
&canonical_workspace_path,
)?;
let (title_value, title_source) = match request.title.as_deref() {
Some(title) => (
normalize_worker_title(title).map_err(|_| DelegationErrorV1::InvalidArguments)?,
DelegationTaskTitleSourceV1::Explicit,
),
None => (
derive_worker_title(&request.input.goal),
DelegationTaskTitleSourceV1::Goal,
),
};
let title_lookup_key = self
.delegation_digest_authority
.worker_title_lookup_digest(&workspace, &title_value)
.as_str()
.to_owned();
// This is only an optimistic snapshot. The same facts are read under the shared
// admission gate immediately before retaining the exact version.
let selected = self.gated_current_start_plan(
&workspace,
&request.plan_id,
AdmissionAction::Start,
&request.submission_key,
)?;
if selected.runtime_blocker.is_some() {
return Err(DelegationErrorV1::CapabilityUnavailable);
}
self.ensure_worker_dependencies(selected.binding.harness, false)?;
let deadline_ms = now_ms
.checked_add(execution.duration_ms)
.ok_or(DelegationErrorV1::DeadlineExceeded)?;
let task_id = random_id("task")?;
let run_id = random_id("run")?;
let lease_id = random_id("lease")?;
let launch_nonce = random_id("launch")?;
let body_scope = ManagedTextScope {
workspace_id: workspace.clone(),
task_id: task_id.clone(),
run_id: run_id.clone(),
};
let body = self.persist_task_input(
&workspace,
&task_id,
&run_id,
&request.input.prompt(),
now_ms,
)?;
let accepted_title = title_value.clone();
let title = DelegationTaskTitleV1 {
value: title_value,
source: title_source,
initial_body_ref: body.clone(),
};
let execution_owner_ref = format!("delegation-run/{run_id}");
let task = DelegationTaskV1 {
workspace_id: workspace.clone(),
task_id: task_id.clone(),
parent_task_ref: request.parent_task_ref.clone(),
plan: selected.binding.clone(),
workspace: workspace_identity,
created_at_ms: now_ms,
latest_run_id: run_id.clone(),
latest_admission_sequence: 0,
title: Some(title),
session: None,
resume_until_ms: 0,
required_body_ids: vec![body.opaque_id.clone()],
body_refs: vec![body],
native_history_paths: vec![],
};
let run = hiroute_domain::delegation::DelegationRunV1 {
workspace_id: workspace.clone(),
task_id,
run_id: run_id.clone(),
ordinal: 1,
continued_from: None,
idempotency_key: request.submission_key.clone(),
request_digest: request_digest.clone(),
admission_sequence: 0,
accepted_at_ms: None,
execution_owner_ref: execution_owner_ref.clone(),
lease_id,
daemon_epoch: self.delegation_epoch.clone(),
permit_id: format!("run-config/{run_id}"),
permit_generation: 1,
configuration: DelegationRunConfigurationV1 {
format_version: DELEGATION_RUN_CONFIGURATION_VERSION_V1,
scope_id: format!("run-config/{run_id}"),
generation: 1,
canonical_workspace_path,
permission_policy: request.permission_policy,
},
execution,
deadline_ms,
lease_revoked: false,
launch_nonce,
process: None,
session: None,
progress: RunProgressV1::default(),
stop_evidence: None,
result_body: None,
result_incomplete: false,
};
let acceptance = DelegationAcceptanceV1 {
task,
run,
title_lookup_key: Some(title_lookup_key),
expected_latest_run_id: None,
admitted_at_ms: now_ms,
};
match canonical_workspace_with_path(&request.cwd) {
Ok((current_workspace, current_path))
if current_workspace == acceptance.task.workspace
&& current_path == acceptance.run.configuration.canonical_workspace_path => {}
Ok(_) => {
self.discard_task_input(&body_scope, now_ms)?;
return Err(DelegationErrorV1::PermissionDenied);
}
Err(error) => {
self.discard_task_input(&body_scope, now_ms)?;
return Err(error);
}
}
let reservation_owner = run_owner(&execution_owner_ref);
let mut reservation_acquired = false;
let admitted = DelegationAdmission {
gate: Arc::clone(&self.plan_admission),
safety: self.delegation_safety.as_ref(),
runtime: self,
}
.accept(&acceptance, |guard, input| {
let current = ExactPlanVersionPort::current_plan(self, guard, &request.plan_id)
.map_err(map_plan_error)?;
if current.status != PlanLifecycleV1::Enabled || current.reference != selected.reference
{
return Err(DelegationErrorV1::Conflict);
}
let refreshed = self.current_start_plan(&workspace, &request.plan_id)?;
if refreshed.reference != selected.reference || refreshed.binding != selected.binding {
return Err(DelegationErrorV1::Conflict);
}
if refreshed.runtime_blocker.is_some() {
return Err(DelegationErrorV1::CapabilityUnavailable);
}
let reservation = VersionReservationV1 {
owner: reservation_owner.clone(),
reference: current.reference,
expires_at_unix: deadline_seconds(input.run.deadline_ms)?,
};
let version = ExactPlanVersionPort::acquire_exact(self, guard, &reservation)
.map_err(map_plan_error)?;
reservation_acquired = true;
if !version.configuration.delegation_enabled
|| version.reference != selected.reference
|| version.configuration.work.as_ref().is_none_or(|work| {
CanonicalDigest::of(work)
.map(|digest| digest != selected.binding.harness_configuration_digest)
.unwrap_or(true)
})
{
return Err(DelegationErrorV1::Conflict);
}
Ok(())
});
match admitted {
Ok(accepted) if accepted.run_id == run_id => Ok(DelegationAcceptedV1 {
schema: DELEGATION_ACCEPTED_SCHEMA_V1.to_owned(),
task_id: accepted.task_id,
run_id: accepted.run_id,
title: Some(accepted_title),
state: accepted.progress.state,
state_revision: accepted.progress.revision,
replayed: false,
}),
Ok(accepted) => {
let cleanup = self.discard_task_input(&body_scope, now_ms);
let release = release_reservation(self, &workspace, &reservation_owner);
cleanup?;
release?;
let task = DelegationRuntimePort::task(self, &workspace, &accepted.task_id)?
.ok_or(DelegationErrorV1::StorageUnavailable)?;
let title = self
.task_content_projection(&task, current_time_ms()?)
.title;
replay_or_conflict(accepted, &request_digest, title)
}
Err(error) => {
let cleanup = self.discard_task_input(&body_scope, now_ms);
let release = if reservation_acquired {
release_reservation(self, &workspace, &reservation_owner)
} else {
Ok(())
};
cleanup?;
release?;
Err(error)
}
}
}
pub(super) fn current_start_plan(
&self,
workspace: &WorkspaceId,
plan_id: &AgentPlanId,
) -> Result<CurrentPlan, DelegationErrorV1> {
let stores = self
.stores_lock()
.map_err(|_| DelegationErrorV1::StorageUnavailable)?;
let control = stores.control();
let record = control
.active_publication(workspace)
.map_err(|_| DelegationErrorV1::StorageUnavailable)?
.ok_or(DelegationErrorV1::CapabilityUnavailable)?;
let publication = record
.verify()
.map_err(|_| DelegationErrorV1::StorageUnavailable)?;
let head = control
.plan_head(workspace, plan_id)
.map_err(map_plan_error)?
.ok_or(DelegationErrorV1::CapabilityUnavailable)?;
if head.status != PlanLifecycleV1::Enabled {
return Err(DelegationErrorV1::CapabilityUnavailable);
}
let version = control
.lookup_exact_plan_version(&head.reference)
.map_err(map_plan_error)?;
if !version.configuration.delegation_enabled {
return Err(DelegationErrorV1::CapabilityUnavailable);
}
let Some(work) = version.configuration.work.clone() else {
return Err(DelegationErrorV1::CapabilityUnavailable);
};
let published = publication
.plans
.iter()
.find(|plan| plan.agent_plan_id() == plan_id)
.ok_or(DelegationErrorV1::CapabilityUnavailable)?;
if published.body.agent_plan_revision != head.reference.content_revision
|| published.model_alias() != &head.model_alias
{
return Err(DelegationErrorV1::Conflict);
}
let harness = work.harness;
let configuration_digest =
CanonicalDigest::of(&work).map_err(|_| DelegationErrorV1::InvalidArguments)?;
Ok(CurrentPlan {
runtime_blocker: super::work_plans::worker_context_blocker(
harness,
version
.compiled
.body
.materialized
.context_window_tokens()
.ok(),
)
.or(super::work_plans::worker_source_blocker(
&stores,
&version.compiled.body.materialized,
)
.map_err(|_| DelegationErrorV1::StorageUnavailable)?),
binding: DelegationPlanBindingV1 {
authority_id: publication.authority_id,
plan_id: plan_id.clone(),
plan_revision: head.reference.content_revision,
plan_digest: head.reference.content_digest.clone(),
publication_revision: record.publication_revision.get(),
publication_digest: record.digest,
exact_reference: exact_reference(&head.reference),
model_alias: head.model_alias.as_str().to_owned(),
harness,
harness_configuration_digest: configuration_digest,
},
reference: head.reference,
})
}
pub(super) fn gated_current_start_plan(
&self,
workspace: &WorkspaceId,
plan_id: &AgentPlanId,
action: AdmissionAction,
stable_action_id: &str,
) -> Result<CurrentPlan, DelegationErrorV1> {
let scope = BTreeSet::from([AdmissionSubject::Plan(plan_id.clone())]);
let _guard = self
.plan_admission
.enter(workspace, &scope, action, stable_action_id)
.map_err(|_| DelegationErrorV1::PermissionDenied)?;
self.current_start_plan(workspace, plan_id)
}
pub(super) fn ensure_worker_dependencies(
&self,
harness: hiroute_domain::delegation::WorkerHarnessV1,
continuing: bool,
) -> Result<(), DelegationErrorV1> {
let selection =
crate::delegation::installation::WorkerInstallationSelectionSource::selection(
self, harness,
)?
.ok_or(DelegationErrorV1::DependenciesMissing)?;
crate::delegation::installation::validate_persisted_installation_for_run(
&selection.config,
continuing,
)
.map(|_| ())
}
}
fn release_reservation(
adapter: &LocalControlAdapter,
workspace: &WorkspaceId,
owner: &VersionOwnerRefV1,
) -> Result<(), DelegationErrorV1> {
ExactPlanVersionPort::release(adapter, workspace, owner).map_err(map_plan_error)
}
fn replay_or_conflict(
run: hiroute_domain::delegation::DelegationRunV1,
request_digest: &CanonicalDigest,
title: Option<String>,
) -> Result<DelegationAcceptedV1, DelegationErrorV1> {
if &run.request_digest != request_digest {
return Err(DelegationErrorV1::Conflict);
}
Ok(DelegationAcceptedV1 {
schema: DELEGATION_ACCEPTED_SCHEMA_V1.to_owned(),
task_id: run.task_id,
run_id: run.run_id,
title,
state: run.progress.state,
state_revision: run.progress.revision,
replayed: true,
})
}
fn keyed_worker_request_digest(
authority: &hiroute_observation::DigestAuthority,
request: &WorkerExecRequestV1,
canonical_workspace_path: &str,
) -> Result<CanonicalDigest, DelegationErrorV1> {
let value = serde_json::json!({
"operation": "exec",
"plan_id": request.plan_id,
"canonical_workspace_path": canonical_workspace_path,
"permission_policy": request.permission_policy,
"run_timeout_secs": request.run_timeout_secs,
"input": request.input,
"title_intent": match request.title.as_deref() {
Some(title) => serde_json::json!({
"source": "explicit",
"value": normalize_worker_title(title)
.map_err(|_| DelegationErrorV1::InvalidArguments)?,
}),
None => serde_json::json!({"source": "goal"}),
},
"parent_task_ref": request.parent_task_ref,
});
let canonical = hiroute_domain::canonicalize_json(value);
let bytes = serde_json::to_vec(&canonical).map_err(|_| DelegationErrorV1::InvalidArguments)?;
Ok(authority.delegation_request_digest(&bytes))
}
pub(super) fn replay_workspace_path(
requested: &str,
accepted_canonical_path: &str,
) -> Result<String, DelegationErrorV1> {
if requested == accepted_canonical_path {
Ok(accepted_canonical_path.to_owned())
} else {
canonical_workspace_with_path(requested).map(|(_, path)| path)
}
}
fn random_id(prefix: &str) -> Result<String, DelegationErrorV1> {
let mut bytes = [0_u8; 16];
getrandom::fill(&mut bytes).map_err(|_| DelegationErrorV1::CapabilityUnavailable)?;
let mut value = String::with_capacity(prefix.len() + 33);
value.push_str(prefix);
value.push('/');
for byte in bytes {
use std::fmt::Write as _;
write!(&mut value, "{byte:02x}").expect("writing to String cannot fail");
}
Ok(value)
}
fn exact_reference(reference: &PlanExecutionRef) -> String {
format!(
"plan/{}/revision/{}/digest/{}",
reference.plan_id.as_str(),
reference.content_revision,
reference.content_digest
)
}
fn map_plan_error(error: PlanVersionError) -> DelegationErrorV1 {
match error {
PlanVersionError::Invalid => DelegationErrorV1::InvalidArguments,
PlanVersionError::Conflict | PlanVersionError::Stale => DelegationErrorV1::Conflict,
PlanVersionError::Unavailable
| PlanVersionError::Disabled
| PlanVersionError::RecoveryRequired => DelegationErrorV1::CapabilityUnavailable,
PlanVersionError::Retained | PlanVersionError::StorageUnavailable => {
DelegationErrorV1::StorageUnavailable
}
}
}