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
//! Streaming content-object installation and durable append replay verification.
use std::fs::{self, File, OpenOptions};
use std::io::{Read, Seek, SeekFrom, Write};
use hiroute_domain::{
CanonicalDigest, ContentId, ConversationContentEnvelopeV1, ConversationContentPhaseV2,
OBSERVATION_ACK_SCHEMA_V2, ObservationAckV2, ObservationBlobAcknowledgementV1,
ObservationDigestSubjectV1,
};
use rusqlite::{OptionalExtension, Transaction, params};
use crate::store::LocalObservationStore;
use super::lifecycle::ContentProjectionError;
type StoredContentEventReplay = (
String,
Vec<u8>,
Option<String>,
Option<i64>,
Option<i64>,
String,
);
pub(crate) fn verify_content_replay(
store: &LocalObservationStore,
transaction: &Transaction<'_>,
envelope: &ConversationContentEnvelopeV1,
digest: &CanonicalDigest,
acknowledgement: &ObservationAckV2,
) -> Result<(), ContentProjectionError> {
let stored: Option<StoredContentEventReplay> = transaction
.query_row(
"SELECT event_id, metadata_json, canonical_chunk_object_ref,
canonical_chunk_byte_offset, canonical_chunk_byte_count, envelope_digest
FROM conversation_content_events_v2
WHERE stream_ref=(SELECT stream_ref FROM observation_streams_v5 WHERE channel='conversation_content' AND producer_id=?1 AND producer_epoch=?2 AND stream_id=?3) AND sequence=?4",
params![
envelope.producer.stream.producer_id.as_str(),
envelope.producer.stream.producer_epoch.as_str(),
envelope.producer.stream.stream_id.as_str(),
i64_from_u64(envelope.sequence)?,
],
|row| {
Ok((
row.get(0)?,
row.get(1)?,
row.get(2)?,
row.get(3)?,
row.get(4)?,
row.get(5)?,
))
},
)
.optional()
.map_err(|_| ContentProjectionError::ActivityStorage)?;
let Some((event_id, metadata, object_ref, stored_offset, stored_count, stored_digest)) = stored
else {
return Err(ContentProjectionError::ContentCorrupt);
};
let mut expected_metadata =
serde_json::to_value(envelope).map_err(|_| ContentProjectionError::ContentCorrupt)?;
expected_metadata
.as_object_mut()
.ok_or(ContentProjectionError::ContentCorrupt)?
.remove("canonical_bytes_base64");
let stored_metadata: serde_json::Value = serde_json::from_slice(
&crate::store::records::decode(&metadata)
.map_err(|_| ContentProjectionError::ContentCorrupt)?,
)
.map_err(|_| ContentProjectionError::ContentCorrupt)?;
if event_id != envelope.event_id.as_str()
|| stored_digest != digest.as_str()
|| stored_metadata != expected_metadata
{
return Err(ContentProjectionError::ContentCorrupt);
}
verify_replayed_acknowledgement(store, transaction, envelope, acknowledgement)?;
if envelope.phase != ConversationContentPhaseV2::Append {
return if object_ref.is_none() && stored_offset.is_none() && stored_count.is_none() {
Ok(())
} else {
Err(ContentProjectionError::ContentCorrupt)
};
}
let content_id = envelope
.content_id
.as_ref()
.ok_or(ContentProjectionError::ContentCorrupt)?;
let ordinal = envelope
.chunk_ordinal
.ok_or(ContentProjectionError::ContentCorrupt)?;
let bytes = decode_base64(
envelope
.canonical_bytes_base64
.as_deref()
.ok_or(ContentProjectionError::ContentCorrupt)?,
)?;
let expected_ref = format!("content-chunk:{content_id}:{ordinal}");
let (path, offset, count, chunk_event_id): (String, i64, i64, String) = transaction
.query_row(
"SELECT object_path, byte_offset, byte_count, event_id FROM content_chunks_v2
WHERE workspace_id=?1 AND content_id=?2 AND chunk_ordinal=?3",
params![
envelope.correlation.workspace_id.as_str(),
content_id.as_str(),
i64::from(ordinal),
],
|row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)),
)
.map_err(|_| ContentProjectionError::ContentCorrupt)?;
if object_ref.as_deref() != Some(expected_ref.as_str())
|| stored_offset != Some(offset)
|| stored_count != Some(count)
|| count != i64_from_u64(bytes.len() as u64)?
|| chunk_event_id != envelope.event_id.as_str()
|| offset < 0
{
return Err(ContentProjectionError::ContentCorrupt);
}
let state: String = transaction
.query_row(
"SELECT state FROM content_instances_v2 WHERE workspace_id=?1 AND content_id=?2",
params![
envelope.correlation.workspace_id.as_str(),
content_id.as_str()
],
|row| row.get(0),
)
.map_err(|_| ContentProjectionError::ContentCorrupt)?;
let mut file = File::open(
store
.object_path(&path)
.map_err(|_| ContentProjectionError::ContentCorrupt)?,
)
.map_err(|_| ContentProjectionError::ContentStorage)?;
let object_offset = if state == "complete" {
u64::try_from(offset).map_err(|_| ContentProjectionError::ContentCorrupt)?
} else if state == "installing" {
0
} else {
return Err(ContentProjectionError::ContentCorrupt);
};
file.seek(SeekFrom::Start(object_offset))
.map_err(|_| ContentProjectionError::ContentStorage)?;
let mut stored_bytes = vec![0; bytes.len()];
file.read_exact(&mut stored_bytes)
.map_err(|_| ContentProjectionError::ContentStorage)?;
if stored_bytes != bytes {
return Err(ContentProjectionError::ContentCorrupt);
}
Ok(())
}
fn verify_replayed_acknowledgement(
store: &LocalObservationStore,
transaction: &Transaction<'_>,
envelope: &ConversationContentEnvelopeV1,
acknowledgement: &ObservationAckV2,
) -> Result<(), ContentProjectionError> {
let stream = &envelope.producer.stream;
let content = acknowledgement
.content_acknowledgement
.as_ref()
.ok_or(ContentProjectionError::ContentCorrupt)?;
let expected_next = match envelope.phase {
ConversationContentPhaseV2::Begin => 0,
ConversationContentPhaseV2::Append => envelope
.chunk_ordinal
.and_then(|ordinal| ordinal.checked_add(1))
.ok_or(ContentProjectionError::ContentCorrupt)?,
ConversationContentPhaseV2::Finish | ConversationContentPhaseV2::Abort => transaction
.query_row(
"SELECT next_chunk_ordinal FROM conversation_content_streams_v2
WHERE producer_id=?1 AND producer_epoch=?2 AND stream_id=?3 AND request_id=?4
AND direction=?5 AND fork_id=?6",
params![
stream.producer_id.as_str(),
stream.producer_epoch.as_str(),
stream.stream_id.as_str(),
envelope.correlation.request_id.as_str(),
envelope.direction.as_str(),
envelope.fork_id,
],
|row| row.get::<_, i64>(0),
)
.map_err(|_| ContentProjectionError::ContentCorrupt)?
.try_into()
.map_err(|_| ContentProjectionError::ContentCorrupt)?,
};
let expected_root = matches!(
envelope.phase,
ConversationContentPhaseV2::Finish | ConversationContentPhaseV2::Abort
)
.then(|| {
envelope
.result_transcript_root
.as_ref()
.map(ToString::to_string)
})
.flatten();
if acknowledgement.schema_version != OBSERVATION_ACK_SCHEMA_V2
|| acknowledgement.identity.channel != "conversation_content"
|| acknowledgement.identity.producer_id != stream.producer_id.as_str()
|| acknowledgement.identity.producer_epoch != stream.producer_epoch.as_str()
|| acknowledgement.identity.stream_id != stream.stream_id.as_str()
|| acknowledgement.highest_contiguous_sequence > acknowledgement.highest_accounted_sequence
|| acknowledgement.highest_accounted_sequence != envelope.sequence
|| content.request_id != envelope.correlation.request_id.as_str()
|| content.direction != envelope.direction
|| content.fork_id != envelope.fork_id
|| content.next_chunk_ordinal != expected_next
|| content.transcript_root != expected_root
|| content.delta_parent_transcript_root
!= envelope
.parent_transcript_root
.as_ref()
.map(ToString::to_string)
{
return Err(ContentProjectionError::ContentCorrupt);
}
for blob in &content.acknowledged_blobs {
verify_acknowledged_blob(store, transaction, envelope, blob)?;
}
if matches!(
envelope.phase,
ConversationContentPhaseV2::Finish | ConversationContentPhaseV2::Abort
) {
let mut statement = transaction
.prepare(
"SELECT content_id, content_blob_digest FROM content_instances_v2
WHERE workspace_id=?1 AND request_id=?2 AND direction=?3 AND fork_id=?4
AND state='complete' ORDER BY content_id",
)
.map_err(|_| ContentProjectionError::ContentCorrupt)?;
let durable = statement
.query_map(
params![
envelope.correlation.workspace_id.as_str(),
envelope.correlation.request_id.as_str(),
envelope.direction.as_str(),
envelope.fork_id,
],
|row| {
Ok(ObservationBlobAcknowledgementV1 {
content_id: row.get(0)?,
digest: row.get(1)?,
})
},
)
.map_err(|_| ContentProjectionError::ContentCorrupt)?
.collect::<Result<Vec<_>, _>>()
.map_err(|_| ContentProjectionError::ContentCorrupt)?;
if durable != content.acknowledged_blobs {
return Err(ContentProjectionError::ContentCorrupt);
}
}
Ok(())
}
fn verify_acknowledged_blob(
store: &LocalObservationStore,
transaction: &Transaction<'_>,
envelope: &ConversationContentEnvelopeV1,
acknowledgement: &ObservationBlobAcknowledgementV1,
) -> Result<(), ContentProjectionError> {
let (digest, path, byte_count, media): (String, String, i64, String) = transaction
.query_row(
"SELECT c.content_blob_digest, b.object_path, b.byte_count, b.media_type
FROM content_instances_v2 c JOIN content_blobs_v2 b
ON b.workspace_id=c.workspace_id AND b.blob_digest=c.content_blob_digest
WHERE c.workspace_id=?1 AND c.request_id=?2 AND c.direction=?3 AND c.fork_id=?4
AND c.content_id=?5 AND c.state='complete' AND b.state='complete'",
params![
envelope.correlation.workspace_id.as_str(),
envelope.correlation.request_id.as_str(),
envelope.direction.as_str(),
envelope.fork_id,
acknowledgement.content_id,
],
|row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)),
)
.map_err(|_| ContentProjectionError::ContentCorrupt)?;
if digest != acknowledgement.digest || byte_count < 0 {
return Err(ContentProjectionError::ContentCorrupt);
}
let mut input = File::open(
store
.object_path(&path)
.map_err(|_| ContentProjectionError::ContentCorrupt)?,
)
.map_err(|_| ContentProjectionError::ContentStorage)?;
let mut accumulator = store.authority.content_accumulator(&media);
let mut observed_count = 0_u64;
let mut buffer = [0_u8; 16 * 1024];
loop {
let read = input
.read(&mut buffer)
.map_err(|_| ContentProjectionError::ContentStorage)?;
if read == 0 {
break;
}
observed_count = observed_count
.checked_add(read as u64)
.ok_or(ContentProjectionError::ContentCorrupt)?;
accumulator.update(&buffer[..read]);
}
let (observed_digest, digested_count) = accumulator.finish();
if observed_count != digested_count
|| observed_count != byte_count as u64
|| observed_digest.as_str() != digest
{
return Err(ContentProjectionError::ContentCorrupt);
}
Ok(())
}
pub(crate) fn finalize_content(
store: &LocalObservationStore,
transaction: &Transaction<'_>,
envelope: &ConversationContentEnvelopeV1,
content_id: &str,
) -> Result<ObservationBlobAcknowledgementV1, ContentProjectionError> {
let (media, expected_digest, expected_count, state): (String, String, Option<i64>, String) =
transaction
.query_row(
"SELECT canonical_media_type, content_blob_digest, expected_byte_count, state
FROM content_instances_v2 WHERE workspace_id=?1 AND content_id=?2",
params![envelope.correlation.workspace_id.as_str(), content_id],
|row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)),
)
.map_err(|_| ContentProjectionError::ActivityStorage)?;
if state == "complete" {
return Ok(ObservationBlobAcknowledgementV1 {
content_id: content_id.into(),
digest: expected_digest,
});
}
let mut statement = transaction
.prepare(
"SELECT object_path FROM content_chunks_v2 WHERE workspace_id=?1 AND content_id=?2
ORDER BY chunk_ordinal",
)
.map_err(|_| ContentProjectionError::ActivityStorage)?;
let paths = statement
.query_map(
params![envelope.correlation.workspace_id.as_str(), content_id],
|row| row.get::<_, String>(0),
)
.map_err(|_| ContentProjectionError::ActivityStorage)?
.collect::<Result<Vec<_>, _>>()
.map_err(|_| ContentProjectionError::ActivityStorage)?;
if paths.is_empty() {
return Err(ContentProjectionError::MissingBlob(vec![
ObservationBlobAcknowledgementV1 {
content_id: content_id.into(),
digest: expected_digest,
},
]));
}
let directory = store.staging_directory(
&envelope.correlation.workspace_id,
&ContentId::parse(content_id.to_owned())
.map_err(|_| ContentProjectionError::ContentCorrupt)?,
);
let install_path = directory.join("install.tmp");
let mut output = OpenOptions::new()
.write(true)
.create(true)
.truncate(true)
.open(&install_path)
.map_err(|_| ContentProjectionError::ContentStorage)?;
let mut accumulator = store.authority.content_accumulator(&media);
let mut buffer = [0_u8; 16 * 1024];
for path in paths {
let mut input = File::open(
store
.object_path(&path)
.map_err(|_| ContentProjectionError::ContentCorrupt)?,
)
.map_err(|_| ContentProjectionError::ContentStorage)?;
loop {
let read = input
.read(&mut buffer)
.map_err(|_| ContentProjectionError::ContentStorage)?;
if read == 0 {
break;
}
accumulator.update(&buffer[..read]);
output
.write_all(&buffer[..read])
.map_err(|_| ContentProjectionError::ContentStorage)?;
}
}
output
.sync_all()
.map_err(|_| ContentProjectionError::ContentStorage)?;
drop(output);
store.note_object_path(&install_path);
let (actual_digest, byte_count) = accumulator.finish();
if actual_digest.as_str() != expected_digest {
return Err(ContentProjectionError::DigestMismatch {
subject: ObservationDigestSubjectV1::ContentBlob,
subject_id: content_id.into(),
expected: expected_digest,
rejected: actual_digest.to_string(),
});
}
if expected_count.is_some_and(|expected| expected != byte_count as i64) {
return Err(ContentProjectionError::DigestMismatch {
subject: ObservationDigestSubjectV1::ContentBlob,
subject_id: content_id.into(),
expected: expected_count.unwrap_or_default().to_string(),
rejected: byte_count.to_string(),
});
}
let blob_path = store.blob_path(actual_digest.as_str());
if blob_path.exists() {
if blob_path
.metadata()
.map_err(|_| ContentProjectionError::ContentStorage)?
.len()
!= byte_count
|| !files_equal(&blob_path, &install_path)?
{
return Err(ContentProjectionError::ContentCorrupt);
}
fs::remove_file(&install_path).map_err(|_| ContentProjectionError::ContentStorage)?;
} else {
fs::rename(&install_path, &blob_path)
.map_err(|_| ContentProjectionError::ContentStorage)?;
}
store.note_object_path(&install_path);
store.note_object_path(&blob_path);
transaction.execute(
"INSERT INTO content_blobs_v2
(workspace_id, blob_digest, object_path, byte_count, media_type, state, created_at_unix_nanos)
VALUES (?1, ?2, ?3, ?4, ?5, 'complete', ?6)
ON CONFLICT(workspace_id, blob_digest) DO NOTHING",
params![envelope.correlation.workspace_id.as_str(), actual_digest.as_str(), store.object_locator(&blob_path).map_err(|_|ContentProjectionError::ContentCorrupt)?,
i64_from_u64(byte_count)?, media, i64_from_u64(envelope.occurred_at_unix_nanos)?],
).map_err(|_| ContentProjectionError::ActivityStorage)?;
transaction
.execute(
"UPDATE content_instances_v2 SET state='complete', accumulated_byte_count=?3
WHERE workspace_id=?1 AND content_id=?2",
params![
envelope.correlation.workspace_id.as_str(),
content_id,
i64_from_u64(byte_count)?
],
)
.map_err(|_| ContentProjectionError::ActivityStorage)?;
transaction
.execute(
"UPDATE content_chunks_v2 SET object_path=?3
WHERE workspace_id=?1 AND content_id=?2",
params![
envelope.correlation.workspace_id.as_str(),
content_id,
store
.object_locator(&blob_path)
.map_err(|_| ContentProjectionError::ContentCorrupt)?,
],
)
.map_err(|_| ContentProjectionError::ActivityStorage)?;
Ok(ObservationBlobAcknowledgementV1 {
content_id: content_id.into(),
digest: actual_digest.to_string(),
})
}
fn i64_from_u64(value: u64) -> Result<i64, ContentProjectionError> {
value
.try_into()
.map_err(|_| ContentProjectionError::Invalid("integer"))
}
fn files_equal(
left: &std::path::Path,
right: &std::path::Path,
) -> Result<bool, ContentProjectionError> {
let mut left = File::open(left).map_err(|_| ContentProjectionError::ContentStorage)?;
let mut right = File::open(right).map_err(|_| ContentProjectionError::ContentStorage)?;
let mut a = [0_u8; 16 * 1024];
let mut b = [0_u8; 16 * 1024];
loop {
let ar = left
.read(&mut a)
.map_err(|_| ContentProjectionError::ContentStorage)?;
let br = right
.read(&mut b)
.map_err(|_| ContentProjectionError::ContentStorage)?;
if ar != br || a[..ar] != b[..br] {
return Ok(false);
}
if ar == 0 {
return Ok(true);
}
}
}
pub(crate) fn decode_base64(value: &str) -> Result<Vec<u8>, ContentProjectionError> {
if !value.len().is_multiple_of(4) {
return Err(ContentProjectionError::Invalid("canonical_bytes_base64"));
}
let mut output = Vec::with_capacity(value.len() / 4 * 3);
for (group_index, group) in value.as_bytes().chunks_exact(4).enumerate() {
let last = group_index + 1 == value.len() / 4;
let a = base64_value(group[0])?;
let b = base64_value(group[1])?;
let c_pad = group[2] == b'=';
let d_pad = group[3] == b'=';
if c_pad && !d_pad || (c_pad || d_pad) && !last {
return Err(ContentProjectionError::Invalid("canonical_bytes_base64"));
}
let c = if c_pad { 0 } else { base64_value(group[2])? };
let d = if d_pad { 0 } else { base64_value(group[3])? };
output.push((a << 2) | (b >> 4));
if !c_pad {
output.push((b << 4) | (c >> 2));
}
if !d_pad {
output.push((c << 6) | d);
}
}
Ok(output)
}
fn base64_value(byte: u8) -> Result<u8, ContentProjectionError> {
match byte {
b'A'..=b'Z' => Ok(byte - b'A'),
b'a'..=b'z' => Ok(byte - b'a' + 26),
b'0'..=b'9' => Ok(byte - b'0' + 52),
b'+' => Ok(62),
b'/' => Ok(63),
_ => Err(ContentProjectionError::Invalid("canonical_bytes_base64")),
}
}