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 crate::{DigestAuthority, LocalObservationStore};
fn input(event: &str, time: i64) -> ManagedTextInput {
ManagedTextInput {
scope: ManagedTextScope {
workspace_id: WorkspaceId::default(),
task_id: "task-a".into(),
run_id: "run-a".into(),
},
purpose: ManagedTextPurpose::Result,
source_event_id: event.into(),
source_revision: 1,
original_created_at_ms: time,
import_origin: None,
}
}
fn store(root: &std::path::Path) -> LocalObservationStore {
LocalObservationStore::open(root, DigestAuthority::new([7; 32])).unwrap()
}
fn complete(store: &LocalObservationStore, input: &ManagedTextInput) -> ManagedTextRef {
let reference = store.managed_text_put(input, 100).unwrap();
store
.managed_text_append(&input.scope, &reference, 0, b"actual result", 100)
.unwrap();
store
.managed_text_finish(&input.scope, &reference, 1, 100)
.unwrap()
}
#[test]
fn event_retries_preserve_deadline_and_conflicting_content_is_rejected() {
let directory = tempfile::tempdir().unwrap();
let store = store(directory.path());
let event = input("event-a", 10);
let reference = complete(&store, &event);
assert_eq!(store.managed_text_put(&event, 200).unwrap(), reference);
assert_eq!(reference.original_retention_deadline_ms, 10 + RETENTION_MS);
store
.managed_text_append(&event.scope, &reference, 0, b"actual result", 200)
.unwrap();
assert_eq!(
store.managed_text_append(&event.scope, &reference, 0, b"different", 200),
Err(ManagedTextError::Conflict)
);
let mut changed = event.clone();
changed.original_created_at_ms = 11;
assert_eq!(
store.managed_text_put(&changed, 200),
Err(ManagedTextError::Conflict)
);
assert_eq!(
store
.managed_text_resolve(&event.scope, &reference, 10 + RETENTION_MS)
.unwrap()
.state,
ManagedTextState::Expired
);
assert_eq!(
store.managed_text_read(&event.scope, &reference, 0, 1, 10 + RETENTION_MS),
Err(ManagedTextError::Unavailable)
);
}
#[test]
fn caller_scope_and_forged_reference_cannot_retrieve_other_run() {
let directory = tempfile::tempdir().unwrap();
let store = store(directory.path());
let event = input("event-a", 10);
let reference = complete(&store, &event);
let mut other = event.scope.clone();
other.run_id = "run-b".into();
assert_eq!(
store.managed_text_read(&other, &reference, 0, 1, 100),
Err(ManagedTextError::ScopeMismatch)
);
let mut forged = reference.clone();
forged.scope = other.clone();
assert_eq!(
store.managed_text_read(&other, &forged, 0, 1, 100),
Err(ManagedTextError::Unavailable)
);
}
#[test]
fn bounded_chunks_page_forward_and_finish_requires_contiguous_committed_chunks() {
let directory = tempfile::tempdir().unwrap();
let store = store(directory.path());
let event = input("event-a", 10);
let reference = store.managed_text_put(&event, 100).unwrap();
assert_eq!(
store.managed_text_append(&event.scope, &reference, 1, b"gap", 100),
Err(ManagedTextError::Conflict)
);
assert_eq!(
store.managed_text_append(&event.scope, &reference, 0, &vec![0; CHUNK_BYTES + 1], 100),
Err(ManagedTextError::Invalid)
);
for ordinal in 0..18 {
store
.managed_text_append(
&event.scope,
&reference,
ordinal,
&vec![ordinal as u8; CHUNK_BYTES],
100,
)
.unwrap();
}
assert_eq!(
store.managed_text_finish(&event.scope, &reference, 19, 100),
Err(ManagedTextError::Conflict)
);
let reference = store
.managed_text_finish(&event.scope, &reference, 18, 100)
.unwrap();
let first = store
.managed_text_read(&event.scope, &reference, 0, 16, 100)
.unwrap();
assert_eq!(first.bytes.len(), PAGE_BYTES);
assert_eq!(first.next_chunk, Some(16));
let last = store
.managed_text_read(&event.scope, &reference, 16, 16, 100)
.unwrap();
assert_eq!(last.bytes.len(), 2 * CHUNK_BYTES);
assert_eq!(last.next_chunk, None);
}
#[test]
fn deletion_survives_restart_blocks_late_import_and_preserves_other_run() {
let directory = tempfile::tempdir().unwrap();
let first = store(directory.path());
let event = input("event-a", 10);
let reference = complete(&first, &event);
let mut other = event.clone();
other.scope.run_id = "run-b".into();
let other_ref = complete(&first, &other);
let preview = first
.managed_text_delete_preview(&event.scope, 100, 100)
.unwrap();
assert_eq!(preview.reference_count, 1);
let result = first.managed_text_delete_apply(&preview).unwrap();
assert!(result.object_gc_pending && result.native_gc_pending);
assert_eq!(first.managed_text_delete_apply(&preview).unwrap(), result);
drop(first);
let restarted = store(directory.path());
let jobs = restarted
.managed_text_pending_native_cleanup(&event.scope, 0, 50)
.unwrap();
assert_eq!(jobs.len(), 1);
assert_eq!(jobs[0].through_ms, 100);
assert_eq!(
restarted
.managed_text_resolve(&event.scope, &reference, 100)
.unwrap()
.state,
ManagedTextState::Deleted
);
assert_eq!(
restarted.managed_text_read(&event.scope, &reference, 0, 1, 100),
Err(ManagedTextError::Unavailable)
);
assert_eq!(
restarted.managed_text_put(&input("late", 99), 100),
Err(ManagedTextError::Unavailable)
);
let mut import = input("renamed-old-history", 10);
import.import_origin = Some(reference);
assert_eq!(
restarted.managed_text_put(&import, 100),
Err(ManagedTextError::Unavailable)
);
assert_eq!(restarted.managed_text_gc(100, 200).unwrap(), 1);
restarted
.managed_text_native_gc_ack(&event.scope, result.visibility_generation)
.unwrap();
let result = restarted.managed_text_delete_apply(&preview).unwrap();
assert!(!result.object_gc_pending && !result.native_gc_pending);
assert!(
restarted
.managed_text_pending_native_cleanup(&event.scope, 0, 50)
.unwrap()
.is_empty()
);
assert_eq!(
restarted
.managed_text_read(&other.scope, &other_ref, 0, 1, 100)
.unwrap()
.bytes,
b"actual result"
);
assert!(restarted.managed_text_put(&input("new", 101), 101).is_ok());
}
#[test]
fn changed_preview_is_stale_and_cancel_has_no_effect() {
let directory = tempfile::tempdir().unwrap();
let store = store(directory.path());
let event = input("event-a", 10);
let reference = complete(&store, &event);
let preview = store
.managed_text_delete_preview(&event.scope, 100, 100)
.unwrap();
assert_eq!(
store
.managed_text_read(&event.scope, &reference, 0, 1, 100)
.unwrap()
.bytes,
b"actual result"
);
complete(&store, &input("event-b", 11));
assert_eq!(
store.managed_text_delete_apply(&preview),
Err(ManagedTextError::Stale)
);
assert_eq!(
store
.managed_text_resolve(&event.scope, &reference, 100)
.unwrap()
.state,
ManagedTextState::Complete
);
}
#[test]
fn import_must_prove_original_deadline_and_current_visibility() {
let directory = tempfile::tempdir().unwrap();
let store = store(directory.path());
let event = input("event-a", 10);
let reference = complete(&store, &event);
let mut import = input("import", 11);
import.import_origin = Some(reference);
assert_eq!(
store.managed_text_put(&import, 100),
Err(ManagedTextError::Unavailable)
);
import.original_created_at_ms = 10;
let imported = store.managed_text_put(&import, 100).unwrap();
assert_eq!(imported.original_retention_deadline_ms, 10 + RETENTION_MS);
}
#[test]
fn interrupted_chunk_is_hidden_retryable_and_collected_after_expiry() {
let directory = tempfile::tempdir().unwrap();
let first = store(directory.path());
let event = input("event-a", 10);
let reference = first.managed_text_put(&event, 100).unwrap();
// Persist exactly the pre-I/O journal and a partially written file, as a
// process interruption would leave them. Neither is a committed body chunk.
use sha2::{Digest, Sha256};
let expected = format!("{:x}", Sha256::digest(b"actual result"));
first.connection.lock().execute(
"INSERT INTO managed_text_chunks(ref_id,ordinal,digest,size,ready) VALUES(?1,0,?2,13,0)",
rusqlite::params![reference.opaque_id, expected],
).unwrap();
std::fs::write(first.managed_chunk_path(&reference.opaque_id, 0), b"act").unwrap();
drop(first);
let restarted = store(directory.path());
assert!(
restarted
.managed_text_read(&event.scope, &reference, 0, 1, 100)
.unwrap()
.bytes
.is_empty()
);
assert_eq!(
restarted.managed_text_finish(&event.scope, &reference, 0, 100),
Err(ManagedTextError::Conflict)
);
restarted
.managed_text_append(&event.scope, &reference, 0, b"actual result", 100)
.unwrap();
restarted
.managed_text_finish(&event.scope, &reference, 1, 100)
.unwrap();
assert_eq!(
restarted
.managed_text_read(&event.scope, &reference, 0, 1, 100)
.unwrap()
.bytes,
b"actual result"
);
assert_eq!(restarted.managed_text_gc(10 + RETENTION_MS, 1).unwrap(), 1);
assert!(
!restarted
.managed_chunk_path(&reference.opaque_id, 0)
.exists()
);
}
#[test]
fn expiry_enqueues_native_cleanup_once_and_does_not_extend_long_run_history() {
let directory = tempfile::tempdir().unwrap();
let store = store(directory.path());
let old = input("old", 10);
let old_ref = complete(&store, &old);
let new = input("new", 20);
let new_ref = complete(&store, &new);
let result = store
.managed_text_expire_scope(&old.scope, 10 + RETENTION_MS)
.unwrap()
.unwrap();
assert_eq!(result.logically_hidden, 1);
assert!(result.native_gc_pending);
assert_eq!(
store
.managed_text_resolve(&old.scope, &old_ref, 10 + RETENTION_MS)
.unwrap()
.state,
ManagedTextState::Expired
);
let new_ref = store
.managed_text_resolve(&new.scope, &new_ref, 10 + RETENTION_MS)
.unwrap();
assert_eq!(
store
.managed_text_read(&new.scope, &new_ref, 0, 1, 10 + RETENTION_MS)
.unwrap()
.bytes,
b"actual result"
);
assert!(
store
.managed_text_expire_scope(&old.scope, 10 + RETENTION_MS)
.unwrap()
.is_none()
);
}
#[test]
fn restart_discovers_expired_scopes_and_durably_schedules_native_cleanup() {
let directory = tempfile::tempdir().unwrap();
let first = input("expiry-a", 10);
let mut second = input("expiry-b", 20);
second.scope.run_id = "run-b".into();
{
let store = store(directory.path());
complete(&store, &first);
complete(&store, &second);
}
let store = store(directory.path());
let now = RETENTION_MS + 100;
assert_eq!(store.managed_text_expire_pending(now, 1).unwrap(), 1);
assert_eq!(store.managed_text_expire_pending(now, 1).unwrap(), 1);
assert_eq!(store.managed_text_expire_pending(now, 1).unwrap(), 0);
for event in [&first, &second] {
let jobs = store
.managed_text_pending_native_cleanup(&event.scope, 0, 10)
.unwrap();
assert_eq!(jobs.len(), 1);
assert_eq!(jobs[0].through_ms, 100);
}
assert_eq!(store.managed_text_gc(now, 1).unwrap(), 1);
assert_eq!(store.managed_text_gc(now, 1).unwrap(), 1);
assert_eq!(store.managed_text_gc(now, 1).unwrap(), 0);
assert_eq!(
store
.managed_text_pending_native_cleanup(&first.scope, 0, 10)
.unwrap()
.len(),
1
);
}
#[test]
fn native_cleanup_page_is_keyset_bounded_and_exact_ack_is_restart_idempotent() {
let directory = tempfile::tempdir().unwrap();
let first = input("ack-first", 10);
let mut second = input("ack-second", 11);
second.scope.task_id = "task-b".into();
second.scope.run_id = "run-b".into();
let first_job;
let second_job;
{
let store = store(directory.path());
complete(&store, &first);
complete(&store, &second);
for event in [&first, &second] {
let preview = store
.managed_text_delete_preview(&event.scope, 100, 100)
.unwrap();
store.managed_text_delete_apply(&preview).unwrap();
}
let page = store
.managed_text_pending_native_cleanup_page(None, 1)
.unwrap();
assert_eq!(page.len(), 1);
let cursor = ManagedTextNativeCleanupCursor {
scope: page[0].scope.clone(),
visibility_generation: page[0].visibility_generation,
};
let next = store
.managed_text_pending_native_cleanup_page(Some(&cursor), 1)
.unwrap();
assert_eq!(next.len(), 1);
assert_ne!(page[0].scope, next[0].scope);
assert!(
store
.managed_text_pending_native_cleanup_page(
Some(&ManagedTextNativeCleanupCursor {
scope: next[0].scope.clone(),
visibility_generation: next[0].visibility_generation,
}),
1,
)
.unwrap()
.is_empty()
);
first_job = page[0].clone();
second_job = next[0].clone();
store.managed_text_native_gc_ack_exact(&first_job).unwrap();
}
let restarted = store(directory.path());
// Crash after the first of several claim jobs: replaying that exact triple is success, so the
// consumer can continue to later jobs instead of becoming permanently stuck at the prefix.
restarted
.managed_text_native_gc_ack_exact(&first_job)
.unwrap();
restarted
.managed_text_native_gc_ack_exact(&second_job)
.unwrap();
let mut wrong = second_job.clone();
wrong.through_ms += 1;
assert_eq!(
restarted.managed_text_native_gc_ack_exact(&wrong),
Err(ManagedTextError::Unavailable)
);
assert!(
restarted
.managed_text_pending_native_cleanup_page(None, 10)
.unwrap()
.is_empty()
);
}