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 hiroute_domain::{
CanonicalDigest, GatewayPublicationRevision, PortError, PortErrorCode, PortResult,
PreparePublicationOutcome, PublicationRecordV1, PublicationRepositoryPort, WorkspaceId,
};
use rusqlite::{OptionalExtension, TransactionBehavior, params};
use super::ControlStore;
impl ControlStore {
/// Removes only the exact still-prepared record owned by a compensating Operation.
pub fn discard_prepared_publication(
&self,
workspace: &WorkspaceId,
publication_revision: GatewayPublicationRevision,
digest: &CanonicalDigest,
) -> PortResult<()> {
let changed = self
.connection
.borrow()
.execute(
"DELETE FROM gateway_publications
WHERE workspace_id = ?1 AND publication_revision = ?2
AND digest = ?3 AND state = 'prepared'",
params![
workspace.as_str(),
publication_revision.get(),
digest.as_str()
],
)
.map_err(|_| port(PortErrorCode::Unavailable, "publication.discard.delete"))?;
if changed == 1 {
Ok(())
} else {
Err(port(
PortErrorCode::Conflict,
"publication.discard.ownership",
))
}
}
}
impl PublicationRepositoryPort for ControlStore {
fn prepare_publication(
&self,
record: &PublicationRecordV1,
expected_active_revision: Option<GatewayPublicationRevision>,
) -> PortResult<PreparePublicationOutcome> {
let publication = record
.verify()
.map_err(|_| port(PortErrorCode::InvalidData, "publication.prepare.verify"))?;
let mut connection = self.connection.borrow_mut();
let transaction = connection
.transaction_with_behavior(TransactionBehavior::Immediate)
.map_err(|_| port(PortErrorCode::Unavailable, "publication.prepare.begin"))?;
let existing: Option<(String, Vec<u8>, String)> = transaction
.query_row(
"SELECT digest, publication_bytes, state FROM gateway_publications
WHERE workspace_id = ?1 AND publication_revision = ?2",
params![
record.workspace_id.as_str(),
record.publication_revision.get()
],
|row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)),
)
.optional()
.map_err(|_| port(PortErrorCode::Unavailable, "publication.prepare.existing"))?;
if let Some((digest, bytes, state)) = existing {
if digest == record.digest.as_str()
&& bytes.as_slice() == record.bytes.as_slice()
&& matches!(state.as_str(), "prepared" | "active")
{
transaction
.commit()
.map_err(|_| port(PortErrorCode::Unavailable, "publication.prepare.commit"))?;
return Ok(PreparePublicationOutcome::ExistingSame);
}
return Err(port(
PortErrorCode::Conflict,
"publication.prepare.revision",
));
}
let active: Option<u64> = transaction
.query_row(
"SELECT active_revision FROM publication_heads WHERE workspace_id = ?1",
params![record.workspace_id.as_str()],
|row| row.get(0),
)
.optional()
.map_err(|_| port(PortErrorCode::Unavailable, "publication.prepare.head"))?
.flatten();
if active != expected_active_revision.map(GatewayPublicationRevision::get)
|| active.is_some_and(|active| active >= record.publication_revision.get())
{
return Err(port(PortErrorCode::Conflict, "publication.prepare.cas"));
}
let active_row: Option<(u64, String, Vec<u8>)> = transaction
.query_row(
"SELECT publication_revision, digest, publication_bytes
FROM gateway_publications
WHERE workspace_id = ?1 AND state = 'active'",
params![record.workspace_id.as_str()],
|row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)),
)
.optional()
.map_err(|_| port(PortErrorCode::Unavailable, "publication.prepare.active"))?;
if active_row.as_ref().map(|row| row.0) != active {
return Err(port(
PortErrorCode::Corrupt,
"publication.prepare.head-mismatch",
));
}
if let Some((revision, digest, bytes)) = active_row {
let active_record = PublicationRecordV1::from_parts(
record.workspace_id.clone(),
GatewayPublicationRevision::new(revision)
.map_err(|_| port(PortErrorCode::Corrupt, "publication.prepare.revision"))?,
CanonicalDigest::parse(digest)
.map_err(|_| port(PortErrorCode::Corrupt, "publication.prepare.digest"))?,
bytes,
)
.map_err(|_| port(PortErrorCode::Corrupt, "publication.prepare.active-verify"))?;
let active_publication = active_record
.verify()
.map_err(|_| port(PortErrorCode::Corrupt, "publication.prepare.active-verify"))?;
publication
.validate_transition_from(&active_publication)
.map_err(|_| port(PortErrorCode::Conflict, "publication.prepare.transition"))?;
}
let prepared_exists: bool = transaction
.query_row(
"SELECT EXISTS(
SELECT 1 FROM gateway_publications
WHERE workspace_id = ?1 AND state = 'prepared'
)",
params![record.workspace_id.as_str()],
|row| row.get(0),
)
.map_err(|_| port(PortErrorCode::Unavailable, "publication.prepare.pending"))?;
if prepared_exists {
return Err(port(PortErrorCode::Conflict, "publication.prepare.pending"));
}
transaction
.execute(
"INSERT INTO gateway_publications(
workspace_id, publication_revision, digest, publication_bytes,
state, created_at, updated_at
) VALUES (?1, ?2, ?3, ?4, 'prepared', unixepoch(), unixepoch())",
params![
record.workspace_id.as_str(),
record.publication_revision.get(),
record.digest.as_str(),
record.bytes.as_slice(),
],
)
.map_err(|_| port(PortErrorCode::Unavailable, "publication.prepare.insert"))?;
transaction
.commit()
.map_err(|_| port(PortErrorCode::Unavailable, "publication.prepare.commit"))?;
Ok(PreparePublicationOutcome::Created)
}
fn prepared_publication(
&self,
workspace: &WorkspaceId,
) -> PortResult<Option<PublicationRecordV1>> {
load_by_state(self, workspace, "prepared")
}
fn active_publication(
&self,
workspace: &WorkspaceId,
) -> PortResult<Option<PublicationRecordV1>> {
load_by_state(self, workspace, "active")
}
fn last_known_good_publication(
&self,
workspace: &WorkspaceId,
) -> PortResult<Option<PublicationRecordV1>> {
load_by_state(self, workspace, "lkg")
}
fn mark_publication_active(
&self,
workspace: &WorkspaceId,
publication_revision: GatewayPublicationRevision,
digest: &CanonicalDigest,
) -> PortResult<()> {
let mut connection = self.connection.borrow_mut();
let transaction = connection
.transaction_with_behavior(TransactionBehavior::Immediate)
.map_err(|_| port(PortErrorCode::Unavailable, "publication.activate.begin"))?;
let row: Option<(String, String)> = transaction
.query_row(
"SELECT digest, state FROM gateway_publications
WHERE workspace_id = ?1 AND publication_revision = ?2",
params![workspace.as_str(), publication_revision.get()],
|row| Ok((row.get(0)?, row.get(1)?)),
)
.optional()
.map_err(|_| port(PortErrorCode::Unavailable, "publication.activate.read"))?;
let Some((stored_digest, state)) = row else {
return Err(port(
PortErrorCode::NotFound,
"publication.activate.missing",
));
};
if stored_digest != digest.as_str() || !matches!(state.as_str(), "prepared" | "active") {
return Err(port(
PortErrorCode::Conflict,
"publication.activate.identity",
));
}
if state == "active" {
transaction
.commit()
.map_err(|_| port(PortErrorCode::Unavailable, "publication.activate.commit"))?;
return Ok(());
}
let prior_active: Option<u64> = transaction
.query_row(
"SELECT active_revision FROM publication_heads WHERE workspace_id = ?1",
params![workspace.as_str()],
|row| row.get(0),
)
.optional()
.map_err(|_| port(PortErrorCode::Unavailable, "publication.activate.head"))?
.flatten();
transaction
.execute(
"UPDATE gateway_publications SET state = 'historical', updated_at = unixepoch()
WHERE workspace_id = ?1 AND state = 'lkg'",
params![workspace.as_str()],
)
.map_err(|_| port(PortErrorCode::Unavailable, "publication.activate.old-lkg"))?;
if let Some(prior_active) = prior_active {
let changed = transaction
.execute(
"UPDATE gateway_publications SET state = 'lkg', updated_at = unixepoch()
WHERE workspace_id = ?1 AND publication_revision = ?2 AND state = 'active'",
params![workspace.as_str(), prior_active],
)
.map_err(|_| port(PortErrorCode::Unavailable, "publication.activate.lkg"))?;
if changed != 1 {
return Err(port(
PortErrorCode::Corrupt,
"publication.activate.head-mismatch",
));
}
}
let changed = transaction
.execute(
"UPDATE gateway_publications SET state = 'active', updated_at = unixepoch()
WHERE workspace_id = ?1 AND publication_revision = ?2 AND state = 'prepared'",
params![workspace.as_str(), publication_revision.get()],
)
.map_err(|_| port(PortErrorCode::Unavailable, "publication.activate.swap"))?;
if changed != 1 {
return Err(port(PortErrorCode::Conflict, "publication.activate.swap"));
}
transaction
.execute(
"INSERT INTO publication_heads(
workspace_id, active_revision, lkg_revision, generation, updated_at
) VALUES (?1, ?2, ?3, 1, unixepoch())
ON CONFLICT(workspace_id) DO UPDATE SET
active_revision = excluded.active_revision,
lkg_revision = excluded.lkg_revision,
generation = publication_heads.generation + 1,
updated_at = unixepoch()",
params![workspace.as_str(), publication_revision.get(), prior_active],
)
.map_err(|_| {
port(
PortErrorCode::Unavailable,
"publication.activate.head-write",
)
})?;
transaction
.commit()
.map_err(|_| port(PortErrorCode::Unavailable, "publication.activate.commit"))?;
Ok(())
}
}
fn load_by_state(
store: &ControlStore,
workspace: &WorkspaceId,
state: &'static str,
) -> PortResult<Option<PublicationRecordV1>> {
let row: Option<(u64, String, Vec<u8>)> = store
.connection
.borrow()
.query_row(
"SELECT publication_revision, digest, publication_bytes
FROM gateway_publications WHERE workspace_id = ?1 AND state = ?2",
params![workspace.as_str(), state],
|row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)),
)
.optional()
.map_err(|_| port(PortErrorCode::Unavailable, "publication.read"))?;
row.map(|(revision, digest, bytes)| {
PublicationRecordV1::from_parts(
workspace.clone(),
GatewayPublicationRevision::new(revision)
.map_err(|_| port(PortErrorCode::Corrupt, "publication.revision"))?,
CanonicalDigest::parse(digest)
.map_err(|_| port(PortErrorCode::Corrupt, "publication.digest"))?,
bytes,
)
.map_err(|_| port(PortErrorCode::Corrupt, "publication.verify"))
})
.transpose()
}
fn port(code: PortErrorCode, context: &'static str) -> PortError {
PortError::new(code, context)
}
#[cfg(test)]
mod routing_publication_storage_tests {
use std::fs;
use crate::test_tempdir as tempdir;
use hiroute_domain::{AliasRegistryV1, GatewayPublicationV1};
use super::*;
fn owner_only(path: &std::path::Path) {
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
fs::set_permissions(path, fs::Permissions::from_mode(0o700)).unwrap();
}
}
fn record(workspace: &WorkspaceId, revision: u64) -> PublicationRecordV1 {
let publication = GatewayPublicationV1::new(
workspace.clone(),
GatewayPublicationRevision::new(revision).unwrap(),
AliasRegistryV1::default(),
Vec::new(),
)
.unwrap();
PublicationRecordV1::from_publication(workspace.clone(), &publication).unwrap()
}
#[test]
fn routing_publication_store_keeps_prepared_active_and_lkg_revisions_distinct() {
let directory = tempdir().unwrap();
owner_only(directory.path());
let store = ControlStore::open(
&crate::test_storage_authority(),
directory.path().join("control.db"),
directory.path().join("backups"),
)
.unwrap();
let workspace = WorkspaceId::default();
let first = record(&workspace, 1);
assert_eq!(
store.prepare_publication(&first, None).unwrap(),
PreparePublicationOutcome::Created
);
assert_eq!(
store.prepared_publication(&workspace).unwrap(),
Some(first.clone())
);
store
.mark_publication_active(&workspace, first.publication_revision, &first.digest)
.unwrap();
assert_eq!(
store.active_publication(&workspace).unwrap(),
Some(first.clone())
);
assert_eq!(
store.prepare_publication(&first, None).unwrap(),
PreparePublicationOutcome::ExistingSame
);
store
.mark_publication_active(&workspace, first.publication_revision, &first.digest)
.unwrap();
let second = record(&workspace, 2);
store
.prepare_publication(&second, Some(first.publication_revision))
.unwrap();
store
.mark_publication_active(&workspace, second.publication_revision, &second.digest)
.unwrap();
assert_eq!(store.active_publication(&workspace).unwrap(), Some(second));
assert_eq!(
store.last_known_good_publication(&workspace).unwrap(),
Some(first)
);
}
#[test]
fn routing_publication_store_rejects_stale_active_revision_before_insert() {
let directory = tempdir().unwrap();
owner_only(directory.path());
let store = ControlStore::open(
&crate::test_storage_authority(),
directory.path().join("control.db"),
directory.path().join("backups"),
)
.unwrap();
let workspace = WorkspaceId::default();
let first = record(&workspace, 1);
store.prepare_publication(&first, None).unwrap();
store
.mark_publication_active(&workspace, first.publication_revision, &first.digest)
.unwrap();
let second = record(&workspace, 2);
let error = store.prepare_publication(&second, None).unwrap_err();
assert_eq!(error.code, PortErrorCode::Conflict);
assert!(store.prepared_publication(&workspace).unwrap().is_none());
}
}