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
//! Legacy content DTO assembly; V2 request pagination lives in query_v2.
use super::*;
use std::fs;
use std::io::Read;
pub(super) fn messages(
connection: &rusqlite::Connection,
store: &LocalObservationStore,
workspace_id: &WorkspaceId,
session_id: &SessionId,
turn_id: &TurnId,
content_mode: ContentMode,
remaining_bytes: &mut usize,
) -> Result<Vec<StoredMessageV1>, ObservationQueryError> {
let mut statement = connection
.prepare(
"SELECT c.message_instance_id, c.content_id, c.content_blob_digest,
s.result_transcript_root, s.parent_transcript_root, c.direction,
c.content_kind, m.message_role, c.canonical_media_type,
c.created_at_unix_nanos, b.object_path, c.request_id, c.fork_id,
m.message_ordinal, c.part_ordinal, s.attempt_id, c.has_content_ref,
c.expected_byte_count, c.transport_frame_id, c.downstream_delivery
FROM logical_requests r INDEXED BY requests_session
CROSS JOIN content_instances_v2 c INDEXED BY content_instances_v2_request
ON c.workspace_id=r.workspace_id AND c.request_id=r.request_id
JOIN content_message_instances_v2 m
ON m.workspace_id=c.workspace_id AND m.message_instance_id=c.message_instance_id
JOIN content_blobs_v2 b
ON b.workspace_id=c.workspace_id AND b.blob_digest=c.content_blob_digest
LEFT JOIN conversation_content_streams_v2 s
ON s.workspace_id=c.workspace_id AND s.request_id=c.request_id
AND s.direction=c.direction AND s.fork_id=c.fork_id
WHERE r.workspace_id=?1 AND r.session_id=?2 AND r.turn_id=?3
AND c.state='complete'
ORDER BY m.message_ordinal, c.part_ordinal, c.content_id LIMIT 201",
)
.map_err(|_| ObservationQueryError::Unavailable)?;
let rows = statement
.query_map(
params![workspace_id.as_str(), session_id.as_str(), turn_id.as_str()],
|row| {
Ok((
row.get::<_, String>(0)?,
row.get::<_, String>(1)?,
row.get::<_, String>(2)?,
row.get::<_, Option<String>>(3)?,
row.get::<_, Option<String>>(4)?,
row.get::<_, String>(5)?,
row.get::<_, String>(6)?,
row.get::<_, String>(7)?,
row.get::<_, String>(8)?,
row.get::<_, i64>(9)?,
row.get::<_, String>(10)?,
row.get::<_, String>(11)?,
row.get::<_, String>(12)?,
row.get::<_, i64>(13)?,
row.get::<_, i64>(14)?,
row.get::<_, Option<String>>(15)?,
row.get::<_, bool>(16)?,
row.get::<_, Option<i64>>(17)?,
row.get::<_, Option<String>>(18)?,
row.get::<_, Option<String>>(19)?,
))
},
)
.map_err(|_| ObservationQueryError::Unavailable)?;
let mut messages = Vec::new();
for row in rows {
let row = row.map_err(|_| ObservationQueryError::Corrupt)?;
if content_mode == ContentMode::Messages && is_tool_kind(&row.6) {
continue;
}
let direction: ConversationContentDirectionV2 = parse_enum(&row.5)?;
let blob_digest =
ContentBlobDigest::parse(row.2).map_err(|_| ObservationQueryError::Corrupt)?;
let content_id =
ContentId::parse(row.1.clone()).map_err(|_| ObservationQueryError::Corrupt)?;
*remaining_bytes = remaining_bytes
.checked_sub(4096)
.ok_or(ObservationQueryError::InvalidQuery)?;
let mut bytes = Vec::new();
fs::File::open(
store
.object_path(&row.10)
.map_err(|_| ObservationQueryError::Corrupt)?,
)
.map_err(|_| ObservationQueryError::Unavailable)?
.take((*remaining_bytes as u64) + 1)
.read_to_end(&mut bytes)
.map_err(|_| ObservationQueryError::Unavailable)?;
*remaining_bytes = remaining_bytes
.checked_sub(bytes.len())
.ok_or(ObservationQueryError::InvalidQuery)?;
let mut accumulator = store.authority.content_accumulator(&row.8);
accumulator.update(&bytes);
if accumulator.finish().0 != blob_digest {
return Err(ObservationQueryError::Corrupt);
}
let content_ref = if row.16 {
Some(ContentRefV2 {
content_id: content_id.clone(),
digest: blob_digest.clone(),
byte_count: row
.17
.ok_or(ObservationQueryError::Corrupt)?
.try_into()
.map_err(|_| ObservationQueryError::Corrupt)?,
media_type: row.8.clone(),
})
} else {
None
};
messages.push(StoredMessageV1 {
request_id: hiroute_domain::LogicalRequestId::parse(row.11)
.map_err(|_| ObservationQueryError::Corrupt)?,
attempt_id: row
.15
.map(AttemptId::parse)
.transpose()
.map_err(|_| ObservationQueryError::Corrupt)?,
fork_id: row.12,
message_instance_id: MessageInstanceId::parse(row.0)
.map_err(|_| ObservationQueryError::Corrupt)?,
content_id,
blob_digest: blob_digest.clone(),
transcript_root: row
.3
.map(TranscriptRoot::parse)
.transpose()
.map_err(|_| ObservationQueryError::Corrupt)?,
parent_transcript_root: row
.4
.map(TranscriptRoot::parse)
.transpose()
.map_err(|_| ObservationQueryError::Corrupt)?,
direction,
message_ordinal: row
.13
.try_into()
.map_err(|_| ObservationQueryError::Corrupt)?,
part_ordinal: row
.14
.try_into()
.map_err(|_| ObservationQueryError::Corrupt)?,
kind: row.6,
role: row.7,
media_type: row.8,
transport_frame_id: row.18,
content_ref,
downstream_delivery: row.19.as_deref().map(parse_enum).transpose()?,
occurred_at_unix_nanos: row
.9
.try_into()
.map_err(|_| ObservationQueryError::Corrupt)?,
bytes,
});
}
Ok(messages)
}
fn is_tool_kind(kind: &str) -> bool {
kind.starts_with("tool_") || kind.contains("tool_call") || kind.contains("tool_result")
}