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 rusqlite::TransactionBehavior;
pub(super) fn register_acceptance(
transaction: &Connection,
input: &DelegationAcceptanceV1,
accepted: &DelegationRunV1,
new_task: bool,
) -> Result<()> {
let task = &input.task;
let root = if new_task {
let relative_root = hiroute_domain::CanonicalDigest::of(&serde_json::json!([
"delegation-native-root-v1",
task.workspace_id,
task.workspace.root_identity,
task.task_id,
task.plan.harness,
]))
.map_err(|_| DelegationErrorV1::InvalidArguments)?
.as_str()
.trim_start_matches("sha256:")
.to_owned();
let root = DelegationNativeRootV1 {
workspace_id: task.workspace_id.clone(),
task_id: task.task_id.clone(),
root_generation: DELEGATION_NATIVE_ROOT_GENERATION_V1,
harness: task.plan.harness,
workspace_root_identity: task.workspace.root_identity.clone(),
relative_root,
creation_nonce: accepted.launch_nonce.clone(),
state: DelegationNativeRootStateV1::Creating,
use_revision: 1,
managed_base_path: None,
filesystem_identity: None,
cleanup_claim: None,
deletion_batches: 0,
last_cleanup_failure: None,
};
root.validate()?;
transaction
.execute(
"INSERT INTO delegation_native_roots(
workspace_id,task_id,root_generation,state,use_revision,record_json
) VALUES(?1,?2,?3,?4,?5,?6)",
params![
root.workspace_id.as_str(),
root.task_id,
root.root_generation,
root_state_name(root.state),
root.use_revision,
encode(&root)?,
],
)
.map_err(storage)?;
root
} else {
let mut root = read_root(transaction, &task.workspace_id, &task.task_id)?
.ok_or(DelegationErrorV1::ResumeUnavailable)?;
if root.state != DelegationNativeRootStateV1::Ready
|| root.harness != task.plan.harness
|| root.workspace_root_identity != task.workspace.root_identity
|| root.cleanup_claim.is_some()
{
return Err(DelegationErrorV1::ResumeUnavailable);
}
root.use_revision = root
.use_revision
.checked_add(1)
.ok_or(DelegationErrorV1::StorageUnavailable)?;
write_root(transaction, &root)?;
root
};
let accepted_at_ms = accepted
.accepted_at_ms
.ok_or(DelegationErrorV1::StorageUnavailable)?;
let usage = DelegationNativeUseV1 {
workspace_id: accepted.workspace_id.clone(),
task_id: accepted.task_id.clone(),
root_generation: root.root_generation,
run_id: accepted.run_id.clone(),
lease_id: accepted.lease_id.clone(),
daemon_epoch: accepted.daemon_epoch.clone(),
accepted_at_ms,
state: DelegationNativeUseStateV1::Accepted,
scope_run_id: accepted.run_id.clone(),
};
usage.validate()?;
transaction
.execute(
"INSERT INTO delegation_native_uses(
workspace_id,task_id,root_generation,run_id,state,record_json
) VALUES(?1,?2,?3,?4,?5,?6)",
params![
usage.workspace_id.as_str(),
usage.task_id,
usage.root_generation,
usage.run_id,
use_state_name(usage.state),
encode(&usage)?,
],
)
.map_err(storage)?;
Ok(())
}
pub(super) fn transition_checkpoint(
transaction: &Connection,
run: &DelegationRunV1,
event: &DelegationCheckpointV1,
) -> Result<()> {
let Some(mut usage) = read_use(transaction, &run.workspace_id, &run.run_id)? else {
return Err(DelegationErrorV1::StorageUnavailable);
};
let next = match event {
DelegationCheckpointV1::Progress {
event: RunEventV1::Preparing,
} if usage.state == DelegationNativeUseStateV1::Accepted => {
Some(DelegationNativeUseStateV1::MayHaveSpawned)
}
DelegationCheckpointV1::Progress {
event: RunEventV1::LaunchFailedBeforeSpawn,
} if matches!(
usage.state,
DelegationNativeUseStateV1::Accepted | DelegationNativeUseStateV1::MayHaveSpawned
) =>
{
Some(DelegationNativeUseStateV1::NeverSpawned)
}
DelegationCheckpointV1::ProcessStopped { evidence }
if evidence.scope_stopped && !evidence.residual_unknown =>
{
Some(DelegationNativeUseStateV1::Stopped)
}
_ => None,
};
let Some(next) = next else { return Ok(()) };
if usage.state == next {
return Ok(());
}
if usage.state.ended() {
return Err(DelegationErrorV1::Conflict);
}
usage.state = next;
write_use(transaction, &usage)?;
let mut root = read_root(transaction, &usage.workspace_id, &usage.task_id)?
.ok_or(DelegationErrorV1::StorageUnavailable)?;
if root.root_generation != usage.root_generation
|| matches!(
root.state,
DelegationNativeRootStateV1::Deleting | DelegationNativeRootStateV1::Removed
)
{
return Err(DelegationErrorV1::Conflict);
}
root.use_revision = root
.use_revision
.checked_add(1)
.ok_or(DelegationErrorV1::StorageUnavailable)?;
if next == DelegationNativeUseStateV1::NeverSpawned
&& root.state == DelegationNativeRootStateV1::Creating
&& read_uses(
transaction,
&root.workspace_id,
&root.task_id,
root.root_generation,
)?
.iter()
.all(|usage| usage.state == DelegationNativeUseStateV1::NeverSpawned)
{
root.state = DelegationNativeRootStateV1::NoNative;
}
write_root(transaction, &root)
}
pub(super) fn register_resume_materials(
transaction: &Connection,
workspace: &WorkspaceId,
task_id: &str,
latest_run_id: &str,
) -> Result<()> {
let mut root =
read_root(transaction, workspace, task_id)?.ok_or(DelegationErrorV1::ResumeUnavailable)?;
let usage = read_use(transaction, workspace, latest_run_id)?
.ok_or(DelegationErrorV1::ResumeUnavailable)?;
if root.state != DelegationNativeRootStateV1::Ready
|| root.cleanup_claim.is_some()
|| usage.task_id != task_id
|| usage.root_generation != root.root_generation
|| usage.state != DelegationNativeUseStateV1::Stopped
{
return Err(DelegationErrorV1::ResumeUnavailable);
}
root.use_revision = root
.use_revision
.checked_add(1)
.ok_or(DelegationErrorV1::StorageUnavailable)?;
write_root(transaction, &root)
}
pub(super) fn read_snapshot(
connection: &Connection,
workspace: &WorkspaceId,
task_id: &str,
) -> Result<Option<DelegationNativeRootSnapshotV1>> {
let Some(root) = read_root(connection, workspace, task_id)? else {
return Ok(None);
};
let uses = read_uses(connection, workspace, task_id, root.root_generation)?;
Ok(Some(DelegationNativeRootSnapshotV1 { root, uses }))
}
pub(super) fn commit_ready(
store: &RuntimeStore,
ready: &DelegationNativeRootReadyV1,
) -> Result<DelegationNativeRootSnapshotV1> {
if ready.root_generation == 0
|| !valid_delegation_id(&ready.task_id)
|| !valid_delegation_id(&ready.creation_nonce)
|| ready.managed_base_path.is_empty()
|| ready.managed_base_path.len() > 4096
|| ready.managed_base_path.contains('\0')
|| !matches!(
ready.filesystem_identity.scheme.as_str(),
"unix-dev-inode-v1" | "windows-volume-file-index-v1"
)
{
return Err(DelegationErrorV1::InvalidArguments);
}
let mut connection = store.connection.borrow_mut();
let transaction = connection
.transaction_with_behavior(TransactionBehavior::Immediate)
.map_err(storage)?;
let mut root = read_root(&transaction, &ready.workspace_id, &ready.task_id)?
.ok_or(DelegationErrorV1::Conflict)?;
if root.root_generation != ready.root_generation
|| root.creation_nonce != ready.creation_nonce
|| root.state != DelegationNativeRootStateV1::Creating
{
return Err(DelegationErrorV1::Conflict);
}
root.state = DelegationNativeRootStateV1::Ready;
root.managed_base_path = Some(ready.managed_base_path.clone());
root.filesystem_identity = Some(ready.filesystem_identity.clone());
write_root(&transaction, &root)?;
let uses = read_uses(
&transaction,
&root.workspace_id,
&root.task_id,
root.root_generation,
)?;
transaction.commit().map_err(storage)?;
Ok(DelegationNativeRootSnapshotV1 { root, uses })
}
pub(super) fn mark_unknown(
store: &RuntimeStore,
workspace: &WorkspaceId,
task_id: &str,
root_generation: u64,
creation_nonce: &str,
) -> Result<()> {
let mut connection = store.connection.borrow_mut();
let transaction = connection
.transaction_with_behavior(TransactionBehavior::Immediate)
.map_err(storage)?;
let mut root =
read_root(&transaction, workspace, task_id)?.ok_or(DelegationErrorV1::Conflict)?;
if root.root_generation != root_generation || root.creation_nonce != creation_nonce {
return Err(DelegationErrorV1::Conflict);
}
match root.state {
DelegationNativeRootStateV1::Creating => {
root.state = DelegationNativeRootStateV1::Unknown;
write_root(&transaction, &root)?;
}
DelegationNativeRootStateV1::Unknown => {}
_ => return Err(DelegationErrorV1::Conflict),
}
transaction.commit().map_err(storage)
}
pub(super) fn claim_cleanup(
store: &RuntimeStore,
workspace: &WorkspaceId,
task_id: &str,
claim: &DelegationNativeCleanupClaimV1,
) -> Result<DelegationNativeRootSnapshotV1> {
let mut connection = store.connection.borrow_mut();
let transaction = connection
.transaction_with_behavior(TransactionBehavior::Immediate)
.map_err(storage)?;
let mut root =
read_root(&transaction, workspace, task_id)?.ok_or(DelegationErrorV1::Conflict)?;
if root.root_generation != claim.root_generation
|| root.use_revision != claim.expected_use_revision
|| !matches!(
root.state,
DelegationNativeRootStateV1::Ready | DelegationNativeRootStateV1::NoNative
)
|| root.cleanup_claim.is_some()
{
return Err(DelegationErrorV1::Conflict);
}
claim.validate_for(&root)?;
let uses = read_uses(
&transaction,
&root.workspace_id,
&root.task_id,
root.root_generation,
)?;
if uses.is_empty()
|| uses.iter().any(|usage| !usage.state.ended())
|| uses.iter().any(|usage| {
!claim
.jobs
.iter()
.any(|job| job.run_id == usage.scope_run_id)
})
|| claim
.jobs
.iter()
.any(|job| !uses.iter().any(|usage| usage.scope_run_id == job.run_id))
{
return Err(DelegationErrorV1::Conflict);
}
root.state = DelegationNativeRootStateV1::Deleting;
root.cleanup_claim = Some(claim.clone());
write_root(&transaction, &root)?;
transaction.commit().map_err(storage)?;
Ok(DelegationNativeRootSnapshotV1 { root, uses })
}
pub(super) fn record_cleanup_batch(
store: &RuntimeStore,
workspace: &WorkspaceId,
task_id: &str,
root_generation: u64,
claim_id: &str,
) -> Result<()> {
update_claimed_root(
store,
workspace,
task_id,
root_generation,
claim_id,
|root| {
root.deletion_batches = root
.deletion_batches
.checked_add(1)
.ok_or(DelegationErrorV1::StorageUnavailable)?;
root.last_cleanup_failure = None;
Ok(())
},
)
.map(|_| ())
}
pub(super) fn record_cleanup_failure(
store: &RuntimeStore,
workspace: &WorkspaceId,
task_id: &str,
root_generation: u64,
claim_id: &str,
kind: DelegationNativeCleanupFailureKindV1,
attempted_at_ms: i64,
) -> Result<()> {
if attempted_at_ms < 0 {
return Err(DelegationErrorV1::InvalidArguments);
}
update_claimed_root(
store,
workspace,
task_id,
root_generation,
claim_id,
|root| {
let attempts = root
.last_cleanup_failure
.as_ref()
.map_or(1, |failure| failure.attempts.saturating_add(1));
root.last_cleanup_failure = Some(DelegationNativeCleanupFailureV1 {
kind,
attempted_at_ms,
attempts,
});
Ok(())
},
)
.map(|_| ())
}
pub(super) fn complete_cleanup(
store: &RuntimeStore,
workspace: &WorkspaceId,
task_id: &str,
root_generation: u64,
claim_id: &str,
) -> Result<DelegationNativeRootSnapshotV1> {
update_claimed_root(
store,
workspace,
task_id,
root_generation,
claim_id,
|root| {
root.state = DelegationNativeRootStateV1::Removed;
root.last_cleanup_failure = None;
Ok(())
},
)
}
fn update_claimed_root(
store: &RuntimeStore,
workspace: &WorkspaceId,
task_id: &str,
root_generation: u64,
claim_id: &str,
update: impl FnOnce(&mut DelegationNativeRootV1) -> Result<()>,
) -> Result<DelegationNativeRootSnapshotV1> {
if !valid_delegation_id(claim_id) {
return Err(DelegationErrorV1::InvalidArguments);
}
let mut connection = store.connection.borrow_mut();
let transaction = connection
.transaction_with_behavior(TransactionBehavior::Immediate)
.map_err(storage)?;
let mut root =
read_root(&transaction, workspace, task_id)?.ok_or(DelegationErrorV1::Conflict)?;
if root.root_generation != root_generation
|| root.state != DelegationNativeRootStateV1::Deleting
|| root
.cleanup_claim
.as_ref()
.map(|claim| claim.claim_id.as_str())
!= Some(claim_id)
{
return Err(DelegationErrorV1::Conflict);
}
update(&mut root)?;
write_root(&transaction, &root)?;
let uses = read_uses(
&transaction,
&root.workspace_id,
&root.task_id,
root.root_generation,
)?;
transaction.commit().map_err(storage)?;
Ok(DelegationNativeRootSnapshotV1 { root, uses })
}
fn read_root(
connection: &Connection,
workspace: &WorkspaceId,
task_id: &str,
) -> Result<Option<DelegationNativeRootV1>> {
let encoded: Option<String> = connection
.query_row(
"SELECT record_json FROM delegation_native_roots
WHERE workspace_id=?1 AND task_id=?2",
params![workspace.as_str(), task_id],
|row| row.get(0),
)
.optional()
.map_err(storage)?;
let root: Option<DelegationNativeRootV1> = encoded.map(decode).transpose()?;
if let Some(root) = &root {
root.validate()
.map_err(|_| DelegationErrorV1::StorageUnavailable)?;
}
Ok(root)
}
fn read_use(
connection: &Connection,
workspace: &WorkspaceId,
run_id: &str,
) -> Result<Option<DelegationNativeUseV1>> {
let encoded: Option<String> = connection
.query_row(
"SELECT record_json FROM delegation_native_uses
WHERE workspace_id=?1 AND run_id=?2",
params![workspace.as_str(), run_id],
|row| row.get(0),
)
.optional()
.map_err(storage)?;
let usage: Option<DelegationNativeUseV1> = encoded.map(decode).transpose()?;
if let Some(usage) = &usage {
usage
.validate()
.map_err(|_| DelegationErrorV1::StorageUnavailable)?;
}
Ok(usage)
}
fn read_uses(
connection: &Connection,
workspace: &WorkspaceId,
task_id: &str,
root_generation: u64,
) -> Result<Vec<DelegationNativeUseV1>> {
let mut statement = connection
.prepare(
"SELECT record_json FROM delegation_native_uses
WHERE workspace_id=?1 AND task_id=?2 AND root_generation=?3 ORDER BY run_id",
)
.map_err(storage)?;
let rows = statement
.query_map(
params![workspace.as_str(), task_id, root_generation],
|row| row.get::<_, String>(0),
)
.map_err(storage)?;
let mut uses = Vec::new();
for row in rows {
let usage: DelegationNativeUseV1 = decode(row.map_err(storage)?)?;
usage
.validate()
.map_err(|_| DelegationErrorV1::StorageUnavailable)?;
uses.push(usage);
if uses.len() > 1024 {
return Err(DelegationErrorV1::StorageUnavailable);
}
}
Ok(uses)
}
fn write_root(connection: &Connection, root: &DelegationNativeRootV1) -> Result<()> {
root.validate()?;
let changed = connection
.execute(
"UPDATE delegation_native_roots
SET state=?1,use_revision=?2,record_json=?3
WHERE workspace_id=?4 AND task_id=?5 AND root_generation=?6",
params![
root_state_name(root.state),
root.use_revision,
encode(root)?,
root.workspace_id.as_str(),
root.task_id,
root.root_generation,
],
)
.map_err(storage)?;
if changed != 1 {
return Err(DelegationErrorV1::Conflict);
}
Ok(())
}
fn write_use(connection: &Connection, usage: &DelegationNativeUseV1) -> Result<()> {
usage.validate()?;
let changed = connection
.execute(
"UPDATE delegation_native_uses SET state=?1,record_json=?2
WHERE workspace_id=?3 AND run_id=?4 AND root_generation=?5",
params![
use_state_name(usage.state),
encode(usage)?,
usage.workspace_id.as_str(),
usage.run_id,
usage.root_generation,
],
)
.map_err(storage)?;
if changed != 1 {
return Err(DelegationErrorV1::Conflict);
}
Ok(())
}
fn root_state_name(state: DelegationNativeRootStateV1) -> &'static str {
match state {
DelegationNativeRootStateV1::Creating => "creating",
DelegationNativeRootStateV1::Ready => "ready",
DelegationNativeRootStateV1::NoNative => "no_native",
DelegationNativeRootStateV1::Unknown => "unknown",
DelegationNativeRootStateV1::Deleting => "deleting",
DelegationNativeRootStateV1::Removed => "removed",
}
}
fn use_state_name(state: DelegationNativeUseStateV1) -> &'static str {
match state {
DelegationNativeUseStateV1::Accepted => "accepted",
DelegationNativeUseStateV1::MayHaveSpawned => "may_have_spawned",
DelegationNativeUseStateV1::Stopped => "stopped",
DelegationNativeUseStateV1::NeverSpawned => "never_spawned",
}
}