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::progress::ProgressLimits;
use super::*;
use crate::{DigestAuthority, LocalObservationStore};
const NOW: i64 = 10_000;
fn store(root: &std::path::Path) -> LocalObservationStore {
LocalObservationStore::open(root, DigestAuthority::new([19; 32])).unwrap()
}
fn target(run_id: &str, created_at_ms: i64) -> ManagedTextProgressTarget {
ManagedTextProgressTarget {
scope: ManagedTextScope {
workspace_id: WorkspaceId::default(),
task_id: format!("task-{run_id}"),
run_id: run_id.to_owned(),
},
created_at_ms,
}
}
fn read_at(
store: &LocalObservationStore,
target: &ManagedTextProgressTarget,
cursor: Option<ManagedTextProgressCursor>,
max_bytes: usize,
now_ms: i64,
) -> Result<ManagedTextProgressRead, ManagedTextProgressReadError> {
store.progress_read_at(target, cursor, max_bytes, now_ms, now_ms)
}
fn available(read: ManagedTextProgressRead) -> ManagedTextProgressPage {
match read {
ManagedTextProgressRead::Available(page) => page,
other => panic!("expected available progress, got {other:?}"),
}
}
#[test]
fn tail_batches_merge_and_idle_checks_do_not_create_or_touch_progress() {
let directory = tempfile::tempdir().unwrap();
let store = store(directory.path());
let target = target("tail", 100);
assert_eq!(
store
.managed_text_progress_write_batch(&target, "", false, NOW)
.unwrap(),
ManagedTextProgressWriteOutcome::Noop
);
let header_count: u64 = store
.connection
.lock()
.query_row("SELECT COUNT(*) FROM managed_text_progress", [], |row| {
row.get(0)
})
.unwrap();
assert_eq!(header_count, 0);
for _ in 0..720 {
store
.managed_text_progress_write_batch(&target, "0123456789abcdef", false, NOW)
.unwrap();
}
let connection = store.connection.lock();
let (blocks, bytes, next_order): (u64, u64, u64) = connection
.query_row(
"SELECT
(SELECT COUNT(*) FROM managed_text_progress_blocks),
(SELECT SUM(length(bytes)) FROM managed_text_progress_blocks),
(SELECT next_order_seq FROM managed_text_progress_meta WHERE singleton=1)",
[],
|row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)),
)
.unwrap();
assert_eq!((blocks, bytes, next_order), (1, 720 * 16, 1));
drop(connection);
let page = available(read_at(&store, &target, None, 32, NOW).unwrap());
assert_eq!(page.window_start, 0);
assert_eq!(page.window_end, 720 * 16);
assert_eq!(page.text, "0123456789abcdef0123456789abcdef");
assert!(page.has_more);
}
#[test]
fn reset_switches_segment_once_and_old_cursor_reports_exact_gap_recovery() {
let directory = tempfile::tempdir().unwrap();
let store = store(directory.path());
let target = target("gap", 100);
store
.managed_text_progress_write_batch(&target, "old", false, NOW)
.unwrap();
let old_cursor = ManagedTextProgressCursor {
visibility_generation: 0,
segment: 0,
position: 3,
};
store
.managed_text_progress_write_batch(&target, "new", true, NOW)
.unwrap();
assert_eq!(
read_at(&store, &target, Some(old_cursor), 32, NOW),
Err(ManagedTextProgressReadError::Gap(
ManagedTextProgressRecovery {
visibility_generation: 0,
segment: 1,
position: 0,
}
))
);
let page = available(read_at(&store, &target, None, 32, NOW).unwrap());
assert_eq!((page.segment, page.text.as_str()), (1, "new"));
store
.managed_text_progress_write_batch(&target, "", true, NOW)
.unwrap();
assert_eq!(
store
.managed_text_progress_write_batch(&target, "", false, NOW)
.unwrap(),
ManagedTextProgressWriteOutcome::Noop
);
let page = available(read_at(&store, &target, None, 32, NOW).unwrap());
assert_eq!(
(page.segment, page.window_start, page.window_end),
(2, 0, 0)
);
}
#[test]
fn per_run_and_global_eviction_preserve_utf8_suffix_and_cursor_truth() {
let directory = tempfile::tempdir().unwrap();
let store = store(directory.path());
let first = target("first", 100);
let second = target("second", 100);
let limits = ProgressLimits {
run_bytes: 8,
global_bytes: 12,
blocks: 8,
block_bytes: 8,
};
store
.progress_write_with_limits(&first, "123456好x", false, NOW, limits)
.unwrap();
let page = available(read_at(&store, &first, None, 32, NOW).unwrap());
assert_eq!((page.window_start, page.window_end), (2, 10));
assert_eq!(page.text, "3456好x");
assert!(page.truncated);
assert_eq!(
read_at(
&store,
&first,
Some(ManagedTextProgressCursor {
visibility_generation: 0,
segment: 0,
position: 0,
}),
32,
NOW,
),
Err(ManagedTextProgressReadError::Evicted(
ManagedTextProgressRecovery {
visibility_generation: 0,
segment: 0,
position: 2,
}
))
);
store
.progress_write_with_limits(&second, "abcdefgh", false, NOW, limits)
.unwrap();
let first_page = available(read_at(&store, &first, None, 32, NOW).unwrap());
assert_eq!(first_page.text, "好x");
assert_eq!(first_page.window_start, 6);
let second_page = available(read_at(&store, &second, None, 32, NOW).unwrap());
assert_eq!(second_page.text, "abcdefgh");
let total: u64 = store
.connection
.lock()
.query_row(
"SELECT SUM(length(bytes)) FROM managed_text_progress_blocks",
[],
|row| row.get(0),
)
.unwrap();
assert_eq!(total, 12);
}
#[test]
fn utf8_cursor_and_page_boundaries_are_exact() {
let directory = tempfile::tempdir().unwrap();
let store = store(directory.path());
let target = target("utf8", 100);
store
.managed_text_progress_write_batch(&target, "é🙂x", false, NOW)
.unwrap();
assert_eq!(
read_at(&store, &target, None, 1, NOW),
Err(ManagedTextProgressReadError::PageTooSmall)
);
let first = available(read_at(&store, &target, None, 2, NOW).unwrap());
assert_eq!((first.text.as_str(), first.next_position), ("é", 2));
assert!(first.has_more);
let second = available(
read_at(
&store,
&target,
Some(ManagedTextProgressCursor {
visibility_generation: 0,
segment: 0,
position: 2,
}),
4,
NOW,
)
.unwrap(),
);
assert_eq!((second.text.as_str(), second.next_position), ("🙂", 6));
assert_eq!(
read_at(
&store,
&target,
Some(ManagedTextProgressCursor {
visibility_generation: 0,
segment: 0,
position: 3,
}),
4,
NOW,
),
Err(ManagedTextProgressReadError::InvalidCursor)
);
}
#[test]
fn missing_deleted_expired_and_fresh_privacy_recheck_are_distinct() {
let directory = tempfile::tempdir().unwrap();
let store = store(directory.path());
let missing = target("missing", 100);
assert_eq!(
read_at(&store, &missing, None, 32, NOW).unwrap(),
ManagedTextProgressRead::Missing {
visibility_generation: 0
}
);
let deleted = target("deleted", 100);
store
.managed_text_progress_write_batch(&deleted, "private", false, NOW)
.unwrap();
let preview = store
.managed_text_delete_preview(&deleted.scope, 100, NOW)
.unwrap();
store.managed_text_delete_apply(&preview).unwrap();
assert_eq!(
read_at(&store, &deleted, None, 32, NOW).unwrap(),
ManagedTextProgressRead::Deleted
);
assert_eq!(
read_at(
&store,
&deleted,
Some(ManagedTextProgressCursor {
visibility_generation: 0,
segment: 0,
position: 0,
}),
32,
NOW,
),
Err(ManagedTextProgressReadError::Stale)
);
assert_eq!(
store
.managed_text_progress_write_batch(&deleted, "late", false, NOW)
.unwrap(),
ManagedTextProgressWriteOutcome::Hidden
);
let expiring = target("expiry", 100);
store
.managed_text_progress_write_batch(&expiring, "old", false, NOW)
.unwrap();
assert_eq!(
store
.progress_read_at(
&expiring,
None,
32,
100 + RETENTION_MS - 1,
100 + RETENTION_MS,
)
.unwrap(),
ManagedTextProgressRead::Expired
);
}
#[test]
fn restart_preserves_atomic_tail_and_corruption_fails_closed() {
let directory = tempfile::tempdir().unwrap();
let target = target("restart", 100);
{
let store = store(directory.path());
store
.managed_text_progress_write_batch(&target, "first", false, NOW)
.unwrap();
store
.managed_text_progress_write_batch(&target, "第二", false, NOW)
.unwrap();
}
let restarted = store(directory.path());
let page = available(read_at(&restarted, &target, None, 32, NOW).unwrap());
assert_eq!(page.text, "first第二");
restarted
.connection
.lock()
.execute(
"UPDATE managed_text_progress_blocks SET digest='bad' WHERE scope=?1",
[target.scope.key().unwrap()],
)
.unwrap();
assert_eq!(
read_at(&restarted, &target, None, 32, NOW),
Err(ManagedTextProgressReadError::Storage)
);
}
#[test]
fn a_missing_tail_block_is_storage_corruption_not_a_short_success_page() {
let directory = tempfile::tempdir().unwrap();
let store = store(directory.path());
let target = target("missing-tail", 100);
let limits = ProgressLimits {
run_bytes: 64,
global_bytes: 64,
blocks: 16,
block_bytes: 4,
};
store
.progress_write_with_limits(&target, "abcdefgh", false, NOW, limits)
.unwrap();
store
.connection
.lock()
.execute(
"DELETE FROM managed_text_progress_blocks WHERE scope=?1 AND start=4",
[target.scope.key().unwrap()],
)
.unwrap();
assert_eq!(
read_at(&store, &target, None, 4, NOW),
Err(ManagedTextProgressReadError::Storage)
);
}
#[test]
fn progress_gc_is_bounded_and_retains_hidden_header() {
let directory = tempfile::tempdir().unwrap();
let store = store(directory.path());
let first = target("gc-first", 10);
let second = target("gc-second", 20);
store
.managed_text_progress_write_batch(&first, "first", false, NOW)
.unwrap();
store
.managed_text_progress_write_batch(&second, "second", false, NOW)
.unwrap();
let now = RETENTION_MS + 10;
assert_eq!(store.managed_text_progress_gc(now, 1).unwrap(), 1);
assert_eq!(store.managed_text_progress_gc(now, 1).unwrap(), 0);
let (headers, blocks): (u64, u64) = store
.connection
.lock()
.query_row(
"SELECT
(SELECT COUNT(*) FROM managed_text_progress),
(SELECT COUNT(*) FROM managed_text_progress_blocks)",
[],
|row| Ok((row.get(0)?, row.get(1)?)),
)
.unwrap();
assert_eq!((headers, blocks), (2, 1));
assert_eq!(
read_at(&store, &first, None, 32, now).unwrap(),
ManagedTextProgressRead::Expired
);
}