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 rusqlite::{OptionalExtension, params};
use super::storage::barrier;
use super::*;
use crate::LocalObservationStore;
impl LocalObservationStore {
/// Discover expired scopes from durable state after restart. Native cleanup
/// must be journaled even when nobody attempts to read the expired reference.
pub fn managed_text_expire_pending(
&self,
now_ms: i64,
limit: usize,
) -> Result<usize, ManagedTextError> {
if now_ms < 0 || limit == 0 || limit > 200 {
return Err(ManagedTextError::Invalid);
}
let scopes = {
let connection = self.connection.lock();
let mut statement = connection.prepare(
"SELECT DISTINCT scope FROM managed_text_refs WHERE deadline_ms<=?1 AND state!='deleted' ORDER BY scope LIMIT ?2"
)?;
statement
.query_map(params![now_ms, limit], |row| row.get::<_, String>(0))?
.collect::<Result<Vec<_>, _>>()?
};
let mut expired = 0;
for encoded in scopes {
let scope: ManagedTextScope =
serde_json::from_str(&encoded).map_err(|_| ManagedTextError::Storage)?;
match self.managed_text_expire_scope(&scope, now_ms) {
Ok(Some(_)) => expired += 1,
Ok(None) | Err(ManagedTextError::Stale) => {}
Err(error) => return Err(error),
}
}
Ok(expired)
}
/// The retention worker schedules exact task scopes. Expiry uses the same
/// durable native-cache cleanup protocol as an explicit deletion.
pub fn managed_text_expire_scope(
&self,
scope: &ManagedTextScope,
now_ms: i64,
) -> Result<Option<ManagedTextDeleteResult>, ManagedTextError> {
let Some(through_ms) = now_ms.checked_sub(RETENTION_MS).filter(|value| *value >= 0) else {
return Ok(None);
};
let preview = self.managed_text_delete_preview(scope, through_ms, now_ms)?;
if preview.reference_count == 0 {
return Ok(None);
}
self.managed_text_delete_apply(&preview).map(Some)
}
/// Recovery polling for the trusted task service. Notifications are an
/// optimization; unacknowledged work persists through either service restart.
pub fn managed_text_pending_native_cleanup(
&self,
scope: &ManagedTextScope,
after_generation: u64,
limit: usize,
) -> Result<Vec<ManagedTextNativeCleanup>, ManagedTextError> {
if limit == 0 || limit > 200 || after_generation > i64::MAX as u64 {
return Err(ManagedTextError::Invalid);
}
let key = scope.key()?;
let connection = self.connection.lock();
let mut statement = connection.prepare(
"SELECT generation,through_ms FROM managed_text_delete_jobs
WHERE scope=?1 AND generation>?2 AND native_gc_pending=1 ORDER BY generation LIMIT ?3",
)?;
let jobs = statement
.query_map(params![key, after_generation, limit], |row| {
Ok(ManagedTextNativeCleanup {
scope: scope.clone(),
visibility_generation: row.get(0)?,
through_ms: row.get(1)?,
})
})?
.collect::<Result<Vec<_>, _>>()?;
Ok(jobs)
}
/// Instance-wide bounded recovery page. `(scope,generation)` is the existing durable key;
/// generations from different scopes are never compared as a global sequence.
pub fn managed_text_pending_native_cleanup_page(
&self,
after: Option<&ManagedTextNativeCleanupCursor>,
limit: usize,
) -> Result<Vec<ManagedTextNativeCleanup>, ManagedTextError> {
if limit == 0 || limit > 200 {
return Err(ManagedTextError::Invalid);
}
let (after_scope, after_generation) = match after {
Some(cursor) if cursor.visibility_generation <= i64::MAX as u64 => {
(Some(cursor.scope.key()?), cursor.visibility_generation)
}
Some(_) => return Err(ManagedTextError::Invalid),
None => (None, 0),
};
let connection = self.connection.lock();
let mut statement = connection.prepare(
"SELECT scope,generation,through_ms FROM managed_text_delete_jobs
WHERE native_gc_pending=1
AND (?1 IS NULL OR scope>?1 OR (scope=?1 AND generation>?2))
ORDER BY scope,generation LIMIT ?3",
)?;
let rows = statement.query_map(
params![after_scope.as_deref(), after_generation, limit],
|row| {
Ok((
row.get::<_, String>(0)?,
row.get::<_, u64>(1)?,
row.get::<_, i64>(2)?,
))
},
)?;
let mut jobs = Vec::new();
for row in rows {
let (scope, visibility_generation, through_ms) = row?;
jobs.push(ManagedTextNativeCleanup {
scope: serde_json::from_str(&scope).map_err(|_| ManagedTextError::Storage)?,
visibility_generation,
through_ms,
});
}
Ok(jobs)
}
pub fn managed_text_scope_cleanup_state(
&self,
scope: &ManagedTextScope,
now_ms: i64,
) -> Result<Option<ManagedTextScopeCleanupState>, ManagedTextError> {
if now_ms < 0 {
return Err(ManagedTextError::Invalid);
}
let key = scope.key()?;
let connection = self.connection.lock();
let scope_row: Option<(u64, i64)> = connection
.query_row(
"SELECT generation,deleted_through_ms FROM managed_text_scopes WHERE scope=?1",
[&key],
|row| Ok((row.get(0)?, row.get(1)?)),
)
.optional()?;
let Some((visibility_generation, deleted_through_ms)) = scope_row else {
return Ok(None);
};
let (reference_count, visible_reference_count, latest_created_ms) = connection.query_row(
"SELECT COUNT(*),
COALESCE(SUM(CASE WHEN state!='deleted' AND deadline_ms>?2 THEN 1 ELSE 0 END),0),
MAX(created_ms)
FROM managed_text_refs WHERE scope=?1",
params![key, now_ms],
|row| {
Ok((
row.get::<_, u64>(0)?,
row.get::<_, u64>(1)?,
row.get::<_, Option<i64>>(2)?,
))
},
)?;
Ok(Some(ManagedTextScopeCleanupState {
visibility_generation,
deleted_through_ms,
reference_count,
visible_reference_count,
latest_created_ms,
}))
}
pub fn managed_text_scope_contains_refs(
&self,
scope: &ManagedTextScope,
opaque_ids: &[String],
) -> Result<bool, ManagedTextError> {
if opaque_ids.is_empty()
|| opaque_ids.len() > 32
|| opaque_ids.iter().any(|id| !valid_id(id))
|| opaque_ids
.iter()
.enumerate()
.any(|(index, id)| opaque_ids[..index].contains(id))
{
return Err(ManagedTextError::Invalid);
}
let key = scope.key()?;
let connection = self.connection.lock();
for id in opaque_ids {
let present: bool = connection.query_row(
"SELECT EXISTS(SELECT 1 FROM managed_text_refs WHERE scope=?1 AND id=?2)",
params![key, id],
|row| row.get(0),
)?;
if !present {
return Ok(false);
}
}
Ok(true)
}
/// Internal operation: the application owns the distinct management grant
/// and exact confirmation, including its operation idempotency identity.
pub fn managed_text_delete_preview(
&self,
scope: &ManagedTextScope,
through_ms: i64,
now_ms: i64,
) -> Result<ManagedTextDeletePreview, ManagedTextError> {
if through_ms < 0 || through_ms > now_ms {
return Err(ManagedTextError::Invalid);
}
let key = scope.key()?;
let connection = self.connection.lock();
let generation = connection
.query_row(
"SELECT generation FROM managed_text_scopes WHERE scope=?1",
[&key],
|row| row.get(0),
)
.optional()?
.unwrap_or(0);
let count = connection.query_row(
"SELECT count(*) FROM managed_text_refs WHERE scope=?1 AND created_ms<=?2 AND state!='deleted'",
params![key,through_ms], |row| row.get(0),
)?;
Ok(ManagedTextDeletePreview {
scope: scope.clone(),
through_ms,
visibility_generation: generation,
reference_count: count,
})
}
pub fn managed_text_delete_apply(
&self,
preview: &ManagedTextDeletePreview,
) -> Result<ManagedTextDeleteResult, ManagedTextError> {
let mut connection = self.connection.lock();
let transaction = connection.transaction()?;
let result = apply_managed_delete(&transaction, preview)?;
transaction.commit()?;
Ok(result)
}
/// Bounded resumable GC. Tombstones remain so delayed writes cannot resurrect
/// old events. Physical failure leaves the chunk queued for the next pass.
pub fn managed_text_gc(&self, now_ms: i64, limit: usize) -> Result<usize, ManagedTextError> {
if limit == 0 || limit > 200 {
return Err(ManagedTextError::Invalid);
}
let connection = self.connection.lock();
let chunks = {
let mut statement = connection.prepare(
"SELECT c.ref_id,c.ordinal FROM managed_text_chunks c
JOIN managed_text_refs r ON r.id=c.ref_id
WHERE r.state='deleted' OR r.deadline_ms<=?1 ORDER BY c.ref_id,c.ordinal LIMIT ?2",
)?;
statement
.query_map(params![now_ms, limit], |row| {
Ok((row.get::<_, String>(0)?, row.get::<_, u64>(1)?))
})?
.collect::<Result<Vec<_>, _>>()?
};
let mut removed = 0;
for (id, ordinal) in chunks {
match std::fs::remove_file(self.managed_chunk_path(&id, ordinal)) {
Ok(()) => {}
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
Err(_) => continue,
}
connection.execute(
"DELETE FROM managed_text_chunks WHERE ref_id=?1 AND ordinal=?2",
params![id, ordinal],
)?;
removed += 1;
}
Ok(removed)
}
pub fn managed_text_native_gc_ack(
&self,
scope: &ManagedTextScope,
generation: u64,
) -> Result<(), ManagedTextError> {
let key = scope.key()?;
let connection = self.connection.lock();
let changed = connection.execute(
"UPDATE managed_text_delete_jobs SET native_gc_pending=0 WHERE scope=?1 AND generation=?2",
params![key,generation],
)?;
if changed == 0 {
return Err(ManagedTextError::Unavailable);
}
Ok(())
}
pub fn managed_text_native_gc_ack_exact(
&self,
job: &ManagedTextNativeCleanup,
) -> Result<(), ManagedTextError> {
let key = job.scope.key()?;
let connection = self.connection.lock();
let changed = connection.execute(
"UPDATE managed_text_delete_jobs SET native_gc_pending=0
WHERE scope=?1 AND generation=?2 AND through_ms=?3 AND native_gc_pending=1",
params![key, job.visibility_generation, job.through_ms],
)?;
if changed == 1 {
return Ok(());
}
let current: Option<(i64, bool)> = connection
.query_row(
"SELECT through_ms,native_gc_pending FROM managed_text_delete_jobs
WHERE scope=?1 AND generation=?2",
params![key, job.visibility_generation],
|row| Ok((row.get(0)?, row.get(1)?)),
)
.optional()?;
if current == Some((job.through_ms, false)) {
Ok(())
} else {
Err(ManagedTextError::Unavailable)
}
}
}
fn has_chunks(
connection: &rusqlite::Connection,
key: &str,
through: i64,
) -> Result<bool, ManagedTextError> {
Ok(connection.query_row(
"SELECT EXISTS(SELECT 1 FROM managed_text_chunks c JOIN managed_text_refs r ON r.id=c.ref_id
WHERE r.scope=?1 AND r.created_ms<=?2 AND r.state='deleted')",
params![key,through], |row| row.get(0),
)?)
}
pub(crate) fn apply_managed_delete(
transaction: &rusqlite::Transaction<'_>,
preview: &ManagedTextDeletePreview,
) -> Result<ManagedTextDeleteResult, ManagedTextError> {
let key = preview.scope.key()?;
let next = preview
.visibility_generation
.checked_add(1)
.filter(|value| *value <= i64::MAX as u64)
.ok_or(ManagedTextError::Invalid)?;
transaction.execute(
"INSERT OR IGNORE INTO managed_text_scopes(scope) VALUES(?1)",
[&key],
)?;
let prior: Option<(i64,u64,bool)> = transaction.query_row(
"SELECT through_ms,hidden_count,native_gc_pending FROM managed_text_delete_jobs WHERE scope=?1 AND generation=?2",
params![key,next], |row| Ok((row.get(0)?,row.get(1)?,row.get(2)?)),
).optional()?;
if let Some((through, count, native_pending)) = prior {
if through != preview.through_ms || count != preview.reference_count {
return Err(ManagedTextError::Stale);
}
return Ok(ManagedTextDeleteResult {
visibility_generation: next,
logically_hidden: count,
object_gc_pending: has_chunks(transaction, &key, preview.through_ms)?,
native_gc_pending: native_pending,
});
}
let (generation, cutoff) = barrier(transaction, &key)?;
let count: u64 = transaction.query_row(
"SELECT count(*) FROM managed_text_refs WHERE scope=?1 AND created_ms<=?2 AND state!='deleted'",
params![key,preview.through_ms], |row| row.get(0),
)?;
if generation != preview.visibility_generation || count != preview.reference_count {
return Err(ManagedTextError::Stale);
}
transaction.execute(
"UPDATE managed_text_scopes SET generation=?2,deleted_through_ms=?3 WHERE scope=?1",
params![key, next, cutoff.max(preview.through_ms)],
)?;
transaction.execute(
"UPDATE managed_text_refs SET state='deleted' WHERE scope=?1 AND created_ms<=?2",
params![key, preview.through_ms],
)?;
transaction.execute(
"INSERT INTO managed_text_delete_jobs(scope,generation,through_ms,hidden_count) VALUES(?1,?2,?3,?4)",
params![key,next,preview.through_ms,count],
)?;
let pending = has_chunks(transaction, &key, preview.through_ms)?;
crate::store::increment_store_revision(transaction).map_err(|_| ManagedTextError::Storage)?;
Ok(ManagedTextDeleteResult {
visibility_generation: next,
logically_hidden: count,
object_gc_pending: pending,
native_gc_pending: true,
})
}