Skip to content

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.

8.9 KB
Raw Blame
//! A complete bounded population in one read transaction. No paging or sampling
//! is allowed to silently bias replay or coverage.
use super::plan_quality::{SAMPLE_SELECT, SCOPE, sample};
use super::{ObservationReaderContext, ObservationV2Error, QueryDeadline, identifier};
use crate::LocalObservationStore;
use hiroute_domain::{TrustObservedStageV1, TrustPopulationQueryV1, TrustPopulationV1};
use rusqlite::{Connection, OpenFlags, named_params};

impl LocalObservationStore {
    pub fn observed_trust_generation(
        &self,
        reader: &ObservationReaderContext,
        now_ms: i64,
    ) -> Result<(u64, u64), ObservationV2Error> {
        reader.check(now_ms, false, false)?;
        let _permit = self.query_permit()?;
        let connection =
            Connection::open_with_flags(&self.activity_path, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
        let _deadline = QueryDeadline::start_for(&connection, reader)?;
        Ok(connection.query_row("SELECT (SELECT CAST(value AS INTEGER) FROM observation_meta WHERE key='plan_quality_generation'), (SELECT CAST(value AS INTEGER) FROM observation_meta WHERE key='query_visibility_generation')", [], |row| Ok((row.get(0)?,row.get(1)?)))?)
    }
    pub fn observed_trust_population(
        &self,
        reader: &ObservationReaderContext,
        query: &TrustPopulationQueryV1,
        now_ms: i64,
    ) -> Result<TrustPopulationV1, ObservationV2Error> {
        self.trust_population(reader, query, now_ms, false)
    }
    pub fn observed_trust_suggestion_population(
        &self,
        reader: &ObservationReaderContext,
        query: &TrustPopulationQueryV1,
        now_ms: i64,
    ) -> Result<TrustPopulationV1, ObservationV2Error> {
        self.trust_population(reader, query, now_ms, true)
    }
    fn trust_population(
        &self,
        reader: &ObservationReaderContext,
        query: &TrustPopulationQueryV1,
        now_ms: i64,
        lean: bool,
    ) -> Result<TrustPopulationV1, ObservationV2Error> {
        reader.check(now_ms, false, false)?;
        if query.active_revision == 0
            || i64::try_from(query.active_revision).is_err()
            || !identifier(&query.plan_id)
            || query.branch_id.as_ref().is_some_and(|id| !identifier(id))
            || query
                .revision
                .is_some_and(|n| n == 0 || i64::try_from(n).is_err())
            || query.from_ms.is_some_and(|v| v < 0)
            || query.to_ms.is_some_and(|v| v < 0)
        {
            return Err(ObservationV2Error::Invalid);
        }
        let retained_from = now_ms
            .saturating_sub(crate::managed_text::RETENTION_MS)
            .saturating_add(1)
            .max(0);
        let from_ms = query.from_ms.unwrap_or(retained_from).max(retained_from);
        let to_ms = query.to_ms.unwrap_or_else(|| now_ms.saturating_add(1));
        if from_ms >= to_ms {
            return Err(ObservationV2Error::Invalid);
        }
        let _permit = self.query_permit()?;
        let mut connection =
            Connection::open_with_flags(&self.activity_path, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
        let _deadline = QueryDeadline::start_for(&connection, reader)?;
        let transaction = connection.transaction()?;
        let generation: u64 = transaction.query_row("SELECT CAST(value AS INTEGER) FROM observation_meta WHERE key='plan_quality_generation'", [], |row| row.get(0))?;
        let runs = reader
            .allowed_runs()
            .map(serde_json::to_string)
            .transpose()
            .map_err(|_| ObservationV2Error::Invalid)?;
        let projection = SAMPLE_SELECT.replace("FROM quality q", ", CASE WHEN l.conflicted=0 THEN json_extract(l.body_json,'$.harness_id') WHEN l.request_id IS NULL THEN (SELECT s.agent_id FROM sessions s WHERE s.workspace_id=q.workspace_id AND s.session_id=q.session_id) END AS executor, EXISTS(SELECT 1 FROM plan_quality_segments later WHERE later.workspace_id=q.workspace_id AND later.session_id=q.session_id AND later.last_observed_turn_ordinal>q.last_observed_turn_ordinal) AS has_later_turn,
            (SELECT json_group_array(json_object('duration_ms',r.finished_at_ms-r.started_at_ms,'output',json_extract(u.usage_json,'$.output')))
             FROM logical_requests r
             JOIN valuation_requests_v2 v ON v.workspace_id=r.workspace_id AND v.request_id=r.request_id
             LEFT JOIN valuation_attempt_inputs_v2 u ON u.workspace_id=v.workspace_id AND u.request_id=v.request_id AND u.ordinal=v.accepted_ordinal
             WHERE r.workspace_id=q.workspace_id AND r.session_id=q.session_id AND v.plan_id=q.plan_id
               AND json_extract(r.route_json,'$.revision')=q.plan_revision
               AND r.started_at_ms >= (SELECT first.started_at_ms FROM logical_requests first WHERE first.workspace_id=q.workspace_id AND first.request_id=q.first_request_id)
               AND r.started_at_ms <= (SELECT last.started_at_ms FROM logical_requests last WHERE last.workspace_id=q.workspace_id AND last.request_id=q.last_request_id)
               AND r.finished_at_ms>=r.started_at_ms) AS performance
            FROM quality q");
        let projection = if lean {
            SAMPLE_SELECT.replace("FROM quality q", ", NULL AS executor, EXISTS(SELECT 1 FROM plan_quality_segments later WHERE later.workspace_id=q.workspace_id AND later.session_id=q.session_id AND later.last_observed_turn_ordinal>q.last_observed_turn_ordinal) AS has_later_turn, '[]' AS performance FROM quality q")
        } else {
            projection
        };
        let scope = if lean {
            format!(
                "SELECT q.*, NULL AS native_model, NULL AS reasoning_profile_id {}",
                &SCOPE[SCOPE
                    .find("FROM plan_quality_segments q")
                    .expect("scope owner")..]
            )
        } else {
            SCOPE.to_owned()
        };
        let population_scope = scope.replace("q.last_at_ms>=:from AND q.last_at_ms<:to", "q.last_at_ms>=:retained AND q.last_at_ms<:now AND (q.plan_revision=:active OR (q.last_at_ms>=:from AND q.last_at_ms<:to AND (:revision IS NULL OR q.plan_revision=:revision)))").replace("AND (:revision IS NULL OR q.plan_revision=:revision)\n", "\n");
        let sql = format!(
            "WITH quality AS ({population_scope}) {projection} WHERE (:branch IS NULL OR COALESCE(q.executed_branch_id,q.selected_branch_id)=:branch) ORDER BY q.last_at_ms,q.segment_id LIMIT 50001"
        );
        let stages = transaction
            .prepare(&sql).map_err(scope_error)?
            .query_map(
                named_params! {
                    ":workspace": reader.workspace().as_str(), ":from": from_ms, ":to": to_ms,
                    ":active": query.active_revision, ":retained": retained_from, ":now": now_ms.saturating_add(1),
                    ":plan": query.plan_id, ":session": Option::<String>::None,
                    ":revision": query.revision, ":runs": runs, ":branch": query.branch_id,
                },
                |row| {
                    let performance: Vec<Performance> = serde_json::from_str(&row.get::<_, String>(39)?).map_err(|_| rusqlite::Error::InvalidQuery)?;
                    Ok(TrustObservedStageV1 {
                        sample: sample(row)?,
                        executor: row.get::<_, Option<String>>(37)?.filter(|s| !s.is_empty()),
                        has_later_turn: row.get(38)?,
                        request_durations_ms: performance.iter().map(|p| p.duration_ms).collect(),
                        output_tokens_per_second: performance.iter().filter(|p| p.duration_ms > 0).filter_map(|p| p.output.map(|tokens| tokens as f64 * 1000.0 / p.duration_ms as f64)).collect(),
                    })
                },
            ).map_err(scope_error)?
            .collect::<Result<Vec<_>, _>>()
            .map_err(scope_error)?;
        if stages.len() > 50_000 {
            return Err(ObservationV2Error::ScopeTooLarge);
        }
        let active_stages = stages
            .iter()
            .filter(|s| s.sample.plan_revision == query.active_revision)
            .cloned()
            .collect();
        let stages = stages
            .into_iter()
            .filter(|s| {
                s.sample.last_at_ms >= from_ms
                    && s.sample.last_at_ms < to_ms
                    && query.revision.is_none_or(|r| s.sample.plan_revision == r)
            })
            .collect();
        transaction.commit()?;
        reader.check(now_ms, false, false)?;
        Ok(TrustPopulationV1 {
            active_stages,
            retained_from_ms: retained_from,
            stages,
            generation,
            from_ms,
            to_ms,
        })
    }
}
fn scope_error(error: rusqlite::Error) -> ObservationV2Error {
    if matches!(error, rusqlite::Error::SqliteFailure(ref code, _) if code.code == rusqlite::ErrorCode::OperationInterrupted)
    {
        ObservationV2Error::ScopeTooLarge
    } else {
        error.into()
    }
}

#[derive(serde::Deserialize)]
struct Performance {
    duration_ms: u64,
    output: Option<u64>,
}