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
//! Retrieval and candidate preparation never hold the feed or Control writer lock.
use super::*;
struct PreparedPublication<P> {
validated: ValidatedFeed,
bytes: Vec<u8>,
etag: Option<String>,
catalog: ReleaseCatalogSnapshot,
counts: FeedCounts,
price: Option<P>,
}
impl ModelFeedService {
pub fn refresh_prepared<P>(
&self,
prepare: impl FnOnce(&ReleaseCatalogSnapshot) -> Result<P, String>,
install: impl FnOnce(
&ReleaseCatalogSnapshot,
P,
&mut dyn FnMut() -> Result<(), String>,
) -> Result<(), String>,
) -> Result<(), String> {
#[cfg(feature = "integration-test-hooks")]
if let Some(root) = product_fixture::root() {
return self.refresh_using_prepared(
|_| product_fixture::download(&root),
prepare,
install,
);
}
self.refresh_using_prepared(
|etag| retrieve_feed(&self.client_version, etag),
prepare,
install,
)
}
#[cfg(test)]
pub(super) fn refresh_using(
&self,
retrieve: impl FnMut(
Option<&str>,
)
-> Result<FeedDownload, hiroute_integrations::model_feed::FeedError>,
install: impl FnOnce(u64, u64) -> Result<(), String>,
) -> Result<(), String> {
self.refresh_using_prepared(
retrieve,
|_| Ok(()),
|catalog, (), commit| {
commit()?;
install(catalog.generation, catalog.accepted_sequence)
},
)
}
pub(crate) fn refresh_using_prepared<P>(
&self,
mut retrieve: impl FnMut(
Option<&str>,
)
-> Result<FeedDownload, hiroute_integrations::model_feed::FeedError>,
prepare: impl FnOnce(&ReleaseCatalogSnapshot) -> Result<P, String>,
install: impl FnOnce(
&ReleaseCatalogSnapshot,
P,
&mut dyn FnMut() -> Result<(), String>,
) -> Result<(), String>,
) -> Result<(), String> {
let (generation, epoch, selected, etag) = {
let mut guard = self.mutable.lock().map_err(|_| "feed_lock")?;
check_mutable(&guard)?;
if guard.refreshing {
while guard.refreshing {
guard = self.refresh_finished.wait(guard).map_err(|_| "feed_lock")?;
}
return guard.last_refresh_result.clone().unwrap_or(Ok(()));
}
guard.refreshing = true;
(
guard.state.generation,
guard.retrieval_epoch,
guard.state.selected_data.clone(),
guard.state.held.as_ref().and(guard.state.etag.clone()),
)
};
let fetched = retrieve(etag.as_deref())
.and_then(|value| {
if matches!(value, FeedDownload::NotModified) && etag.is_none() {
retrieve(None)
} else {
Ok(value)
}
})
.map_err(|e| failure_code(e.kind).to_owned());
// Even large snapshots are parsed, qualified and price-prepared before either writer lock.
let prepared = fetched.and_then(|download| match download {
FeedDownload::Content { bytes, etag } => {
let validated = parse_feed(&bytes).map_err(|e| failure_code(e.kind).to_owned())?;
let incoming = DataFloor {
revision: validated.payload.data_revision,
digest: validated.payload.data_digest.clone(),
};
let semantic_change = selected.as_ref() != Some(&incoming);
let admission = admit(&self.embedded, &validated.payload, &self.client_version)
.map_err(|e| e.to_string())?;
let catalog = ReleaseCatalogSnapshot {
catalog: self
.embedded
.with_feed(&admission)
.map_err(|e| e.to_string())?,
generation: if semantic_change {
generation
.checked_add(1)
.ok_or("feed_generation_overflow")?
} else {
generation
},
accepted_sequence: validated.payload.sequence,
};
let price = if semantic_change {
Some(prepare(&catalog)?)
} else {
None
};
Ok((
Some(PreparedPublication {
validated,
bytes,
etag,
catalog,
counts: admission.counts,
price,
}),
"ok",
))
}
FeedDownload::NotModified => Ok((None, "not_modified")),
FeedDownload::NotPublished => Ok((None, "not_published")),
});
let mut guard = self.mutable.lock().map_err(|_| "feed_lock")?;
guard.refreshing = false;
let result = if generation != guard.state.generation || epoch != guard.retrieval_epoch {
Err("feed_retrieval_superseded".into())
} else {
prepared.and_then(|(prepared, code)| match prepared {
Some(prepared) => self.apply_prepared(&mut guard, prepared, install),
None if code == "not_modified" && guard.state.held.is_none() => {
Err("cacheless_not_modified".into())
}
None => Ok(code),
})
};
let (code, reason) = match &result {
Ok(code) => ((*code).to_owned(), None),
Err(reason) => (attempt_failure_code(reason).into(), Some(reason.clone())),
};
guard.state.last_attempt = Some(FeedAttempt {
at_ms: now_ms(),
result: code,
reason,
});
guard.failures = if result.is_ok() {
0
} else {
guard.failures.saturating_add(1)
};
let delay = if guard.failures == 0 {
330 * 60 * 1000 + jitter_ms(60 * 60 * 1000)
} else {
(15 * 60 * 1000_u64).saturating_mul(1 << guard.failures.min(4).saturating_sub(1))
};
guard.next_attempt = guard.state.retrieval_enabled.then(|| now_ms() + delay);
let result = self.store.commit(&guard.state).and(result.map(|_| ()));
guard.last_refresh_result = Some(result.clone());
self.refresh_finished.notify_all();
result
}
fn apply_prepared<P>(
&self,
guard: &mut MutableFeed,
prepared: PreparedPublication<P>,
install: impl FnOnce(
&ReleaseCatalogSnapshot,
P,
&mut dyn FnMut() -> Result<(), String>,
) -> Result<(), String>,
) -> Result<&'static str, String> {
let PreparedPublication {
validated,
bytes,
etag,
catalog,
counts,
price,
} = prepared;
if validated.payload.sequence <= guard.state.sequence_floor
&& !guard.state.highest_accepted.as_ref().is_some_and(|h| {
h.sequence >= guard.state.sequence_floor && h.sequence == validated.payload.sequence
})
{
return Err("older_sequence".into());
}
if let Some(high) = &guard.state.highest_accepted {
if validated.payload.sequence < high.sequence {
return Err("older_sequence".into());
}
if validated.payload.sequence == high.sequence {
if validated.payload_digest != high.payload_digest {
return Err("same_sequence_conflicting_digest".into());
}
if guard.state.held.is_some() {
return Ok("already_current");
}
}
}
let incoming = DataFloor {
revision: validated.payload.data_revision,
digest: validated.payload.data_digest.clone(),
};
if let Some(floor) = &guard.state.data_floor {
if incoming.revision < floor.revision {
return Err("older_data_revision".into());
}
if incoming.revision == floor.revision && incoming.digest != floor.digest {
return Err("same_data_revision_conflicting_digest".into());
}
}
let mut next = guard.state.clone();
next.generation = catalog.generation;
next.data_floor = Some(incoming.clone());
next.selected_data = Some(incoming);
next.highest_accepted = Some(HighestAccepted {
sequence: validated.payload.sequence,
payload_digest: validated.payload_digest.clone(),
});
next.held = Some(HeldPublication {
sequence: validated.payload.sequence,
payload_digest: validated.payload_digest.clone(),
retrieved_at_ms: now_ms(),
issued_at: validated.payload.issued_at,
});
next.etag = etag;
next.last_success_at_ms = Some(now_ms());
// Content-addressed bytes grant no authority until the checkpoint/state is committed.
self.store.persist_blob(&bytes, &validated.payload_digest)?;
let mut committed = false;
self.active.store(false, Ordering::Release);
let result = if let Some(price) = price {
let mut commit = || {
if committed {
return Err("feed_duplicate_commit".into());
}
self.store.commit(&next)?;
committed = true;
Ok(())
};
install(&catalog, price, &mut commit)
} else {
self.store.commit(&next).map(|()| {
committed = true;
})
};
if let Err(error) = result {
if committed {
guard.state = next;
guard.counts = counts;
guard.refused = Some("feed_activation_requires_restart".into());
guard.recovery_available = false;
}
self.active.store(true, Ordering::Release);
return Err(error);
}
if !committed {
self.active.store(true, Ordering::Release);
return Err("feed_missing_commit".into());
}
guard.state = next;
guard.counts = counts;
self.current.store(Arc::new(catalog));
self.active.store(true, Ordering::Release);
self.store.retire_unreferenced(guard.state.held.as_ref());
Ok("ok")
}
}