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 std::fs::{self, OpenOptions};
use std::io::Write;
use hiroute_domain::{
ContentId, ConversationContentEnvelopeV1, ConversationContentPhaseV2,
ObservationBlobAcknowledgementV1, ObservationDigestSubjectV1, TranscriptRoot,
};
use rusqlite::{OptionalExtension, Transaction, params};
use crate::store::LocalObservationStore;
use super::projection::{
accumulated_actual_str, accumulated_expected, accumulated_expected_str, acknowledged_blobs,
content_digest, coordinate_params, ensure_scope, enum_json, event_file_key, i64_from_u64,
insert_or_verify, insert_transcript_root, load_stream, missing_blobs, projection_digest,
terminal_phase, touch_content_session, validate_stream_coordinates,
};
use super::storage::{decode_base64, finalize_content};
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub(crate) struct ContentProjectionAck {
pub transcript_root: Option<String>,
pub delta_parent_transcript_root: Option<String>,
pub acknowledged_blobs: Vec<ObservationBlobAcknowledgementV1>,
pub next_chunk_ordinal: u32,
pub chunk_object_ref: Option<String>,
pub chunk_byte_offset: Option<u64>,
pub chunk_byte_count: Option<u64>,
pub cleanup_content_ids: Vec<ContentId>,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum ContentProjectionError {
UnknownTranscriptRoot(TranscriptRoot),
MissingBlob(Vec<ObservationBlobAcknowledgementV1>),
ContentStateConflict {
expected: ConversationContentPhaseV2,
rejected: ConversationContentPhaseV2,
},
ChunkOrdinalConflict {
expected: u32,
rejected: u32,
},
DigestMismatch {
subject: ObservationDigestSubjectV1,
subject_id: String,
expected: String,
rejected: String,
},
ImmutableConflict {
key: String,
existing: String,
rejected: String,
},
Invalid(&'static str),
ActivityStorage,
ContentStorage,
ContentCorrupt,
}
pub(crate) fn apply_content(
store: &LocalObservationStore,
transaction: &Transaction<'_>,
envelope: &ConversationContentEnvelopeV1,
) -> Result<ContentProjectionAck, ContentProjectionError> {
match envelope.phase {
ConversationContentPhaseV2::Begin => apply_begin(transaction, envelope),
ConversationContentPhaseV2::Append => apply_append(store, transaction, envelope),
ConversationContentPhaseV2::Finish | ConversationContentPhaseV2::Abort => {
apply_terminal(store, transaction, envelope)
}
}
}
fn apply_begin(
transaction: &Transaction<'_>,
envelope: &ConversationContentEnvelopeV1,
) -> Result<ContentProjectionAck, ContentProjectionError> {
ensure_scope(transaction, envelope)?;
if let Some(parent) = &envelope.parent_transcript_root {
let exists: bool = transaction
.query_row(
"SELECT EXISTS(SELECT 1 FROM transcript_roots_v2
WHERE workspace_id=?1 AND transcript_root=?2 AND conversation_id=?3)",
params![
envelope.correlation.workspace_id.as_str(),
parent.as_str(),
envelope.correlation.conversation_id.as_str(),
],
|row| row.get(0),
)
.map_err(|_| ContentProjectionError::ActivityStorage)?;
if !exists {
return Err(ContentProjectionError::UnknownTranscriptRoot(
parent.clone(),
));
}
}
let inserted = transaction
.execute(
"INSERT OR IGNORE INTO conversation_content_streams_v2
(workspace_id, producer_id, producer_epoch, stream_id, request_id, direction,
fork_id, conversation_id, session_scope, correlation_provenance, turn_id,
attempt_id, parent_transcript_root, state, next_chunk_ordinal, begin_sequence,
completeness, updated_at_unix_nanos)
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13,
'open', 0, ?14, 'unknown', ?15)",
params![
envelope.correlation.workspace_id.as_str(),
envelope.producer.stream.producer_id.as_str(),
envelope.producer.stream.producer_epoch.as_str(),
envelope.producer.stream.stream_id.as_str(),
envelope.correlation.request_id.as_str(),
envelope.direction.as_str(),
envelope.fork_id,
envelope.correlation.conversation_id.as_str(),
enum_json(&envelope.correlation.session_scope)?,
enum_json(&envelope.correlation.correlation_provenance)?,
envelope.correlation.turn_id.as_str(),
envelope.attempt_id.as_ref().map(|value| value.as_str()),
envelope
.parent_transcript_root
.as_ref()
.map(|value| value.as_str()),
i64_from_u64(envelope.sequence)?,
i64_from_u64(envelope.occurred_at_unix_nanos)?,
],
)
.map_err(|_| ContentProjectionError::ActivityStorage)?;
if inserted == 0 {
return Err(ContentProjectionError::ContentStateConflict {
expected: ConversationContentPhaseV2::Append,
rejected: ConversationContentPhaseV2::Begin,
});
}
touch_content_session(transaction, envelope)?;
Ok(ContentProjectionAck {
delta_parent_transcript_root: envelope
.parent_transcript_root
.as_ref()
.map(ToString::to_string),
..ContentProjectionAck::default()
})
}
fn apply_append(
store: &LocalObservationStore,
transaction: &Transaction<'_>,
envelope: &ConversationContentEnvelopeV1,
) -> Result<ContentProjectionAck, ContentProjectionError> {
let mut stream = load_stream(transaction, envelope)?;
if stream.state != "open" {
return Err(ContentProjectionError::ContentStateConflict {
expected: terminal_phase(&stream.state),
rejected: ConversationContentPhaseV2::Append,
});
}
validate_stream_coordinates(&stream, envelope)?;
let rejected = envelope
.chunk_ordinal
.ok_or(ContentProjectionError::Invalid("chunk_ordinal"))?;
if rejected != stream.next_chunk_ordinal {
return Err(ContentProjectionError::ChunkOrdinalConflict {
expected: stream.next_chunk_ordinal,
rejected,
});
}
let content_id = envelope
.content_id
.as_ref()
.ok_or(ContentProjectionError::Invalid("content_id"))?;
let mut cleanup_content_ids = Vec::new();
let mut acknowledged_blobs = Vec::new();
if let Some(active) = stream.active_content_id.as_deref()
&& active != content_id.as_str()
{
let acknowledgement = finalize_content(store, transaction, envelope, active)?;
cleanup_content_ids.push(
ContentId::parse(active.to_owned())
.map_err(|_| ContentProjectionError::ContentCorrupt)?,
);
acknowledged_blobs.push(acknowledgement);
stream.active_content_id = None;
}
ensure_message_and_content(transaction, envelope)?;
let (prior_byte_count, expected_byte_count, content_state) = transaction
.query_row(
"SELECT accumulated_byte_count, 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.as_str()
],
|row| {
Ok((
row.get::<_, i64>(0)?,
row.get::<_, Option<i64>>(1)?,
row.get::<_, String>(2)?,
))
},
)
.map_err(|_| ContentProjectionError::ActivityStorage)?;
if content_state != "installing" {
return Err(ContentProjectionError::ContentStateConflict {
expected: ConversationContentPhaseV2::Finish,
rejected: ConversationContentPhaseV2::Append,
});
}
let bytes = decode_base64(
envelope
.canonical_bytes_base64
.as_deref()
.ok_or(ContentProjectionError::Invalid("canonical_bytes_base64"))?,
)?;
let directory = store.staging_directory(&envelope.correlation.workspace_id, content_id);
fs::create_dir_all(&directory).map_err(|_| ContentProjectionError::ContentStorage)?;
let path = directory.join(format!(
"{rejected:010}-{}.chunk",
event_file_key(envelope.event_id.as_str())
));
match OpenOptions::new().write(true).create_new(true).open(&path) {
Ok(mut file) => file
.write_all(&bytes)
.and_then(|()| file.sync_all())
.map_err(|_| ContentProjectionError::ContentStorage)?,
Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => {
let existing = fs::read(&path).map_err(|_| ContentProjectionError::ContentStorage)?;
if existing != bytes {
return Err(ContentProjectionError::ChunkOrdinalConflict {
expected: rejected,
rejected,
});
}
}
Err(_) => return Err(ContentProjectionError::ContentStorage),
}
store.note_object_path(&path);
transaction
.execute(
"INSERT INTO content_chunks_v2
(workspace_id, content_id, chunk_ordinal, object_path, byte_offset, byte_count,
event_id)
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)",
params![
envelope.correlation.workspace_id.as_str(),
content_id.as_str(),
i64::from(rejected),
store
.object_locator(&path)
.map_err(|_| ContentProjectionError::ContentCorrupt)?,
prior_byte_count,
i64_from_u64(bytes.len() as u64)?,
envelope.event_id.as_str(),
],
)
.map_err(|_| ContentProjectionError::ActivityStorage)?;
let accumulated = prior_byte_count
.checked_add(i64_from_u64(bytes.len() as u64)?)
.ok_or(ContentProjectionError::Invalid("canonical_bytes_base64"))?;
if accumulated < 0 || expected_byte_count.is_some_and(|expected| accumulated > expected) {
return Err(ContentProjectionError::DigestMismatch {
subject: ObservationDigestSubjectV1::ContentBlob,
subject_id: content_id.to_string(),
expected: expected_byte_count
.map_or_else(|| "unknown".into(), |value| value.to_string()),
rejected: accumulated.to_string(),
});
}
transaction
.execute(
"UPDATE content_instances_v2 SET accumulated_byte_count=?3
WHERE workspace_id=?1 AND content_id=?2",
params![
envelope.correlation.workspace_id.as_str(),
content_id.as_str(),
accumulated
],
)
.map_err(|_| ContentProjectionError::ActivityStorage)?;
let next = rejected
.checked_add(1)
.ok_or(ContentProjectionError::Invalid("chunk_ordinal"))?;
transaction
.execute(
"UPDATE conversation_content_streams_v2
SET next_chunk_ordinal=?7, active_content_id=?8, updated_at_unix_nanos=?9
WHERE producer_id=?1 AND producer_epoch=?2 AND stream_id=?3 AND request_id=?4
AND direction=?5 AND fork_id=?6",
params![
envelope.producer.stream.producer_id.as_str(),
envelope.producer.stream.producer_epoch.as_str(),
envelope.producer.stream.stream_id.as_str(),
envelope.correlation.request_id.as_str(),
envelope.direction.as_str(),
envelope.fork_id,
i64::from(next),
content_id.as_str(),
i64_from_u64(envelope.occurred_at_unix_nanos)?,
],
)
.map_err(|_| ContentProjectionError::ActivityStorage)?;
let expected = accumulated_expected(transaction, envelope, content_id)?;
if expected.is_some_and(|expected| expected == accumulated as u64) {
acknowledged_blobs.push(finalize_content(
store,
transaction,
envelope,
content_id.as_str(),
)?);
cleanup_content_ids.push(content_id.clone());
transaction
.execute(
"UPDATE conversation_content_streams_v2 SET active_content_id=NULL
WHERE producer_id=?1 AND producer_epoch=?2 AND stream_id=?3 AND request_id=?4
AND direction=?5 AND fork_id=?6",
coordinate_params(envelope),
)
.map_err(|_| ContentProjectionError::ActivityStorage)?;
}
touch_content_session(transaction, envelope)?;
Ok(ContentProjectionAck {
delta_parent_transcript_root: stream.parent_root,
acknowledged_blobs,
next_chunk_ordinal: next,
chunk_object_ref: Some(format!("content-chunk:{content_id}:{rejected}")),
chunk_byte_offset: Some(
prior_byte_count
.try_into()
.map_err(|_| ContentProjectionError::ContentCorrupt)?,
),
chunk_byte_count: Some(bytes.len() as u64),
cleanup_content_ids,
..ContentProjectionAck::default()
})
}
fn apply_terminal(
store: &LocalObservationStore,
transaction: &Transaction<'_>,
envelope: &ConversationContentEnvelopeV1,
) -> Result<ContentProjectionAck, ContentProjectionError> {
let stream = load_stream(transaction, envelope)?;
if stream.state != "open" {
return Err(ContentProjectionError::ContentStateConflict {
expected: terminal_phase(&stream.state),
rejected: envelope.phase,
});
}
validate_stream_coordinates(&stream, envelope)?;
let mut cleanup_content_ids = Vec::new();
if let Some(active) = stream.active_content_id.as_deref() {
let expected = accumulated_expected_str(transaction, &stream.workspace_id, active)?;
let actual = accumulated_actual_str(transaction, &stream.workspace_id, active)?;
if expected.is_some_and(|expected| expected != actual) {
let digest = content_digest(transaction, &stream.workspace_id, active)?;
return Err(ContentProjectionError::MissingBlob(vec![
ObservationBlobAcknowledgementV1 {
content_id: active.into(),
digest,
},
]));
}
finalize_content(store, transaction, envelope, active)?;
cleanup_content_ids.push(
ContentId::parse(active.to_owned())
.map_err(|_| ContentProjectionError::ContentCorrupt)?,
);
}
let incomplete = missing_blobs(transaction, envelope)?;
if !incomplete.is_empty() {
return Err(ContentProjectionError::MissingBlob(incomplete));
}
let result = envelope
.result_transcript_root
.as_ref()
.ok_or(ContentProjectionError::Invalid("result_transcript_root"))?;
insert_transcript_root(transaction, envelope, result)?;
let state = envelope.phase.as_str();
let completeness = match envelope.completeness_delta {
Some(hiroute_domain::ContentCompletenessDeltaV2::Complete) => "complete",
Some(hiroute_domain::ContentCompletenessDeltaV2::Partial) => "partial",
Some(hiroute_domain::ContentCompletenessDeltaV2::Unknown) | None => "unknown",
};
transaction
.execute(
"UPDATE conversation_content_streams_v2
SET state=?7, result_transcript_root=?8, active_content_id=NULL,
terminal_sequence=?9, completeness=?10, updated_at_unix_nanos=?11
WHERE producer_id=?1 AND producer_epoch=?2 AND stream_id=?3 AND request_id=?4
AND direction=?5 AND fork_id=?6",
params![
envelope.producer.stream.producer_id.as_str(),
envelope.producer.stream.producer_epoch.as_str(),
envelope.producer.stream.stream_id.as_str(),
envelope.correlation.request_id.as_str(),
envelope.direction.as_str(),
envelope.fork_id,
state,
result.as_str(),
i64_from_u64(envelope.sequence)?,
completeness,
i64_from_u64(envelope.occurred_at_unix_nanos)?,
],
)
.map_err(|_| ContentProjectionError::ActivityStorage)?;
touch_content_session(transaction, envelope)?;
Ok(ContentProjectionAck {
transcript_root: Some(result.to_string()),
delta_parent_transcript_root: stream.parent_root,
acknowledged_blobs: acknowledged_blobs(transaction, envelope)?,
next_chunk_ordinal: stream.next_chunk_ordinal,
cleanup_content_ids,
..ContentProjectionAck::default()
})
}
fn ensure_message_and_content(
transaction: &Transaction<'_>,
envelope: &ConversationContentEnvelopeV1,
) -> Result<(), ContentProjectionError> {
let message = envelope
.message_instance_id
.as_ref()
.ok_or(ContentProjectionError::Invalid("message_instance_id"))?;
let content = envelope
.content_id
.as_ref()
.ok_or(ContentProjectionError::Invalid("content_id"))?;
let message_ordinal = envelope
.message_ordinal
.ok_or(ContentProjectionError::Invalid("message_ordinal"))?;
let part_ordinal = envelope
.part_ordinal
.ok_or(ContentProjectionError::Invalid("part_ordinal"))?;
let role = envelope
.message_role
.as_deref()
.ok_or(ContentProjectionError::Invalid("message_role"))?;
let kind = envelope
.content_kind
.as_deref()
.ok_or(ContentProjectionError::Invalid("content_kind"))?;
let media = envelope
.canonical_media_type
.as_deref()
.ok_or(ContentProjectionError::Invalid("canonical_media_type"))?;
let digest = envelope
.content_blob_digest
.as_ref()
.ok_or(ContentProjectionError::Invalid("content_blob_digest"))?;
let occurred_at = i64_from_u64(envelope.occurred_at_unix_nanos)?;
let logical_message: Option<(String, String)> = transaction
.query_row(
"SELECT message_instance_id, message_role FROM content_message_instances_v2
WHERE workspace_id=?1 AND request_id=?2 AND direction=?3 AND fork_id=?4
AND message_ordinal=?5",
params![
envelope.correlation.workspace_id.as_str(),
envelope.correlation.request_id.as_str(),
envelope.direction.as_str(),
envelope.fork_id,
i64::from(message_ordinal),
],
|row| Ok((row.get(0)?, row.get(1)?)),
)
.optional()
.map_err(|_| ContentProjectionError::ActivityStorage)?;
let rejected_message = (message.to_string(), role.to_owned());
if logical_message
.as_ref()
.is_some_and(|existing| existing != &rejected_message)
{
return Err(ContentProjectionError::ImmutableConflict {
key: format!(
"message_ordinal:{}:{}:{}:{}",
envelope.correlation.request_id,
envelope.direction.as_str(),
envelope.fork_id,
message_ordinal,
),
existing: projection_digest(&logical_message),
rejected: projection_digest(&rejected_message),
});
}
let message_projection = serde_json::json!([
envelope.correlation.conversation_id.as_str(),
envelope.correlation.request_id.as_str(),
envelope.direction.as_str(),
envelope.fork_id,
message_ordinal,
role
]);
insert_or_verify(
transaction,
"content_message_instances_v2",
envelope.correlation.workspace_id.as_str(),
message.as_str(),
&message_projection,
|| {
transaction.execute(
"INSERT INTO content_message_instances_v2
(workspace_id, message_instance_id, conversation_id, request_id, direction, fork_id,
message_ordinal, message_role, occurred_at_unix_nanos)
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)",
params![
envelope.correlation.workspace_id.as_str(),
message.as_str(),
envelope.correlation.conversation_id.as_str(),
envelope.correlation.request_id.as_str(),
envelope.direction.as_str(),
envelope.fork_id,
i64::from(message_ordinal),
role,
occurred_at
],
)
},
|| {
transaction.query_row(
"SELECT conversation_id, request_id, direction, fork_id, message_ordinal, message_role
FROM content_message_instances_v2 WHERE workspace_id=?1 AND message_instance_id=?2",
params![envelope.correlation.workspace_id.as_str(), message.as_str()],
|row| Ok(serde_json::json!([row.get::<_, String>(0)?, row.get::<_, String>(1)?,
row.get::<_, String>(2)?, row.get::<_, String>(3)?, row.get::<_, i64>(4)?,
row.get::<_, String>(5)?])),
)
},
)?;
let expected_count = envelope.content_ref.as_ref().map(|value| value.byte_count);
let expected_count_sql = expected_count.map(i64_from_u64).transpose()?;
let has_content_ref = envelope.content_ref.is_some();
let delivery = envelope
.downstream_delivery
.as_ref()
.map(enum_json)
.transpose()?;
let content_projection = serde_json::json!([
message.as_str(),
envelope.correlation.request_id.as_str(),
envelope.direction.as_str(),
envelope.fork_id,
part_ordinal,
kind,
media,
digest.as_str(),
expected_count,
has_content_ref,
envelope.transport_frame_id,
delivery
]);
insert_or_verify(
transaction,
"content_instances_v2",
envelope.correlation.workspace_id.as_str(),
content.as_str(),
&content_projection,
|| {
transaction.execute(
"INSERT INTO content_instances_v2
(workspace_id, content_id, message_instance_id, request_id, direction, fork_id,
part_ordinal, content_kind, canonical_media_type, content_blob_digest,
expected_byte_count, has_content_ref, transport_frame_id, downstream_delivery,
accumulated_byte_count, state, created_at_unix_nanos)
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14,
0, 'installing', ?15)",
params![
envelope.correlation.workspace_id.as_str(),
content.as_str(),
message.as_str(),
envelope.correlation.request_id.as_str(),
envelope.direction.as_str(),
envelope.fork_id,
i64::from(part_ordinal),
kind,
media,
digest.as_str(),
expected_count_sql,
has_content_ref,
envelope.transport_frame_id,
delivery,
occurred_at
],
)
},
|| {
transaction.query_row(
"SELECT message_instance_id, request_id, direction, fork_id, part_ordinal,
content_kind, canonical_media_type, content_blob_digest, expected_byte_count,
has_content_ref, transport_frame_id, downstream_delivery
FROM content_instances_v2 WHERE workspace_id=?1 AND content_id=?2",
params![envelope.correlation.workspace_id.as_str(), content.as_str()],
|row| {
Ok(serde_json::json!([
row.get::<_, String>(0)?,
row.get::<_, String>(1)?,
row.get::<_, String>(2)?,
row.get::<_, String>(3)?,
row.get::<_, i64>(4)?,
row.get::<_, String>(5)?,
row.get::<_, String>(6)?,
row.get::<_, String>(7)?,
row.get::<_, Option<i64>>(8)?,
row.get::<_, bool>(9)?,
row.get::<_, Option<String>>(10)?,
row.get::<_, Option<String>>(11)?
]))
},
)
},
)?;
let reference_projection =
serde_json::json!([message.as_str(), content.as_str(), digest.as_str()]);
let reference_key = format!(
"{}:{}:{}:{message_ordinal}:{part_ordinal}",
envelope.correlation.request_id,
envelope.direction.as_str(),
envelope.fork_id,
);
insert_or_verify(
transaction,
"request_content_refs_v2",
envelope.correlation.workspace_id.as_str(),
&reference_key,
&reference_projection,
|| {
transaction.execute(
"INSERT INTO request_content_refs_v2
(workspace_id, request_id, direction, fork_id, message_instance_id, content_id,
message_ordinal, part_ordinal, blob_digest)
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)",
params![
envelope.correlation.workspace_id.as_str(),
envelope.correlation.request_id.as_str(),
envelope.direction.as_str(),
envelope.fork_id,
message.as_str(),
content.as_str(),
i64::from(message_ordinal),
i64::from(part_ordinal),
digest.as_str()
],
)
},
|| {
transaction.query_row(
"SELECT message_instance_id, content_id, blob_digest FROM request_content_refs_v2
WHERE workspace_id=?1 AND request_id=?2 AND direction=?3 AND fork_id=?4
AND message_ordinal=?5 AND part_ordinal=?6",
params![
envelope.correlation.workspace_id.as_str(),
envelope.correlation.request_id.as_str(),
envelope.direction.as_str(),
envelope.fork_id,
i64::from(message_ordinal),
i64::from(part_ordinal)
],
|row| {
Ok(serde_json::json!([
row.get::<_, String>(0)?,
row.get::<_, String>(1)?,
row.get::<_, String>(2)?
]))
},
)
},
)?;
Ok(())
}