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.

11.1 KB
Raw Blame
use super::*;
use hiroute_domain::{
    CanonicalDigest, ContentCompleteness, ObservationSessionCorrelationKindV1,
    ObservationSessionPageV2, ObservationSessionSummaryV2,
};
use rusqlite::{Connection, OpenFlags, params};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
struct SessionCursor {
    schema: String,
    binding: String,
    visibility: u64,
    watermark: i64,
    last_at: i64,
    last_id: String,
}

impl crate::LocalObservationStore {
    /// Group only matching authorized requests, never an unscoped session's
    /// counts or most recent model. Aggregation and keyset paging share one
    /// read snapshot and deadline; no request-page loop builds the list.
    pub fn observed_sessions(
        &self,
        reader: &ObservationReaderContext,
        query: &ObservationRequestQuery,
        now_ms: i64,
    ) -> Result<ObservationSessionPageV2, ObservationV2Error> {
        if query.cursor.is_some() {
            return self.observed_sessions_once(reader, query, now_ms);
        }
        let deadline = reader
            .query_deadline()
            .unwrap_or_else(|| std::time::Instant::now() + std::time::Duration::from_millis(500));
        let reader = reader.clone().with_query_deadline(deadline);
        match self.observed_sessions_once(&reader, query, now_ms) {
            // Automatic retention can invalidate a snapshot while this first
            // page is being read. Retry once under the SAME original deadline;
            // never return removed membership or silently reset a paged cursor.
            Err(ObservationV2Error::Stale) => self.observed_sessions_once(&reader, query, now_ms),
            result => result,
        }
    }

    fn observed_sessions_once(
        &self,
        reader: &ObservationReaderContext,
        query: &ObservationRequestQuery,
        now_ms: i64,
    ) -> Result<ObservationSessionPageV2, ObservationV2Error> {
        reader.check(now_ms, false, false)?;
        if query.from_ms < 0
            || query.from_ms >= query.to_ms
            || query.limit == 0
            || query.limit > 200
            || [
                &query.session_id,
                &query.request_id,
                &query.agent_id,
                &query.plan_id,
                &query.native_model,
                &query.outcome,
            ]
            .into_iter()
            .flatten()
            .any(|id| !identifier(id))
        {
            return Err(ObservationV2Error::Invalid);
        }
        let _permit = self.query_permit()?;
        let mut normalized = query.clone();
        normalized.cursor = None;
        let binding = CanonicalDigest::of(&(reader.binding()?, normalized))
            .map_err(|_| ObservationV2Error::Invalid)?
            .to_string();
        let mut connection =
            Connection::open_with_flags(&self.activity_path, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
        let _deadline = QueryDeadline::start_for(&connection, reader)?;
        let tx = connection.transaction()?;
        let visibility = tx.query_row("SELECT CAST(value AS INTEGER) FROM observation_meta WHERE key='query_visibility_generation'", [], |row| row.get(0))?;
        let cursor = match &query.cursor {
            Some(encoded) => {
                let cursor: SessionCursor = self.decode_observation_cursor(encoded)?;
                if cursor.schema != "sessions/v2"
                    || cursor.binding != binding
                    || cursor.visibility != visibility
                {
                    return Err(ObservationV2Error::Stale);
                }
                cursor
            }
            None => SessionCursor {
                schema: "sessions/v2".into(),
                binding,
                visibility,
                watermark: tx.query_row(
                    "SELECT COALESCE(MAX(rowid),0) FROM logical_requests",
                    [],
                    |r| r.get(0),
                )?,
                last_at: i64::MAX,
                last_id: String::new(),
            },
        };
        let runs = reader
            .allowed_runs()
            .map(serde_json::to_string)
            .transpose()
            .map_err(|_| ObservationV2Error::Invalid)?;
        let mut sessions = {
            let request_state = crate::content::completeness::REQUEST_STATE;
            let sql = format!(
                "{}, visible AS (
                 SELECT r.session_id,s.agent_id,r.started_at_ms,r.session_scope,
                   r.correlation_provenance,l.run_id,l.conflicted,
                   CASE WHEN s.content_completeness IN ('deleted','expired') THEN s.content_completeness
                     ELSE {request_state} END AS content_state,
                   (SELECT COUNT(DISTINCT a.model_id) FROM observation_attempt_models_v2 a WHERE a.workspace_id=r.workspace_id AND a.request_id=r.request_id) AS models,
                   EXISTS(SELECT 1 FROM turn_changes t WHERE t.request_id=r.request_id AND t.changed=1) AS turn_change
                 FROM logical_requests r JOIN sessions s ON s.workspace_id=r.workspace_id AND s.session_id=r.session_id
                 LEFT JOIN observation_run_links l ON l.workspace_id=r.workspace_id AND l.request_id=r.request_id
                 WHERE r.workspace_id=?1 AND r.started_at_ms>=?2 AND r.started_at_ms<?3 AND r.rowid<=?4
                   AND (?5 IS NULL OR r.session_id=?5) AND (?6 IS NULL OR s.agent_id=?6)
                   AND (?7 IS NULL OR EXISTS(SELECT 1 FROM valuation_requests_v2 v WHERE v.workspace_id=r.workspace_id AND v.request_id=r.request_id AND v.plan_id=?7))
                   AND (?8 IS NULL OR EXISTS(SELECT 1 FROM observation_attempt_models_v2 a WHERE a.workspace_id=r.workspace_id AND a.request_id=r.request_id AND a.model_id=?8))
                   AND (?9 IS NULL OR r.outcome=?9)
                   AND (?10 IS NULL OR EXISTS(SELECT 1 FROM observation_run_links l WHERE l.workspace_id=r.workspace_id AND l.request_id=r.request_id AND l.conflicted=0 AND l.run_id IN(SELECT value FROM json_each(?10))))
                   AND (?15 IS NULL OR r.request_id=?15)
                   AND (s.tombstone_reason IS NULL OR EXISTS(SELECT 1 FROM observation_tombstones t WHERE t.workspace_id=r.workspace_id AND t.session_id=r.session_id AND t.delete_scope='content_only'))
                 ), grouped AS (
                   SELECT session_id,agent_id,MIN(started_at_ms) AS first_at,MAX(started_at_ms) AS last_at,COUNT(*) AS requests,SUM(models>1) AS fallbacks,SUM(models=0) AS unknown_models,
                     CASE
                       WHEN SUM(CASE WHEN conflicted=1 THEN 1 ELSE 0 END)>0 THEN 0
                       WHEN SUM(CASE WHEN session_scope='conversation' AND correlation_provenance='protocol_state' AND run_id IS NOT NULL AND conflicted=0 THEN 0 ELSE 1 END)=0
                            AND COUNT(DISTINCT run_id)=1 THEN 2
                       WHEN SUM(CASE WHEN session_scope='conversation' AND correlation_provenance='agent_supplied' THEN 0 ELSE 1 END)=0 THEN 1
                       WHEN SUM(CASE WHEN session_scope='conversation' AND correlation_provenance='gateway_generated' THEN 0 ELSE 1 END)=0 THEN 3
                       WHEN SUM(CASE WHEN session_scope='request_scoped' AND correlation_provenance='unproven' THEN 0 ELSE 1 END)=0 THEN 4
                       ELSE 0
                     END AS correlation_kind,
                     CASE WHEN MAX(content_state='deleted')=1 THEN 'deleted'
                       WHEN MAX(content_state='expired')=1 THEN 'expired'
                       WHEN MAX(content_state='partial')=1 THEN 'partial'
                       WHEN MAX(content_state='unknown')=1 THEN 'unknown'
                       ELSE 'complete' END AS content_state
                   FROM visible WHERE (?11=0 OR models>1 OR turn_change) GROUP BY session_id,agent_id
                 ) SELECT session_id,agent_id,first_at,last_at,requests,fallbacks,unknown_models,correlation_kind,content_state FROM grouped
                 WHERE last_at<?12 OR (last_at=?12 AND session_id>?13)
                 ORDER BY last_at DESC,session_id LIMIT ?14", super::turns::cte(10, "?4"));
            let mut stmt = tx.prepare(&sql)?;
            stmt.query_map(
                params![
                    reader.workspace().as_str(),
                    query.from_ms.max(
                        now_ms
                            .saturating_sub(crate::managed_text::RETENTION_MS)
                            .saturating_add(1)
                    ),
                    query.to_ms,
                    cursor.watermark,
                    query.session_id,
                    query.agent_id,
                    query.plan_id,
                    query.native_model,
                    query.outcome,
                    runs,
                    query.only_model_switch,
                    cursor.last_at,
                    cursor.last_id,
                    u64::from(query.limit) + 1,
                    query.request_id
                ],
                |r| {
                    Ok(ObservationSessionSummaryV2 {
                        session_id: r.get(0)?,
                        agent_id: r.get(1)?,
                        first_request_at_ms: r.get(2)?,
                        last_request_at_ms: r.get(3)?,
                        request_count: r.get(4)?,
                        fallback_request_count: r.get(5)?,
                        unknown_model_request_count: r.get(6)?,
                        content_completeness: match r.get::<_, String>(8)?.as_str() {
                            "complete" => ContentCompleteness::Complete,
                            "partial" => ContentCompleteness::Partial,
                            "deleted" => ContentCompleteness::Deleted,
                            "expired" => ContentCompleteness::Expired,
                            _ => ContentCompleteness::Unknown,
                        },
                        correlation_kind: match r.get::<_, u8>(7)? {
                            1 => ObservationSessionCorrelationKindV1::AgentSupplied,
                            2 => ObservationSessionCorrelationKindV1::VerifiedWorker,
                            3 => ObservationSessionCorrelationKindV1::Inferred,
                            4 => ObservationSessionCorrelationKindV1::RequestScoped,
                            _ => ObservationSessionCorrelationKindV1::Unknown,
                        },
                    })
                },
            )?
            .collect::<Result<Vec<_>, _>>()?
        };
        let more = sessions.len() > usize::from(query.limit);
        sessions.truncate(usize::from(query.limit));
        let next_cursor = if more {
            let last = sessions.last().ok_or(ObservationV2Error::Unavailable)?;
            Some(self.encode_observation_cursor(&SessionCursor {
                last_at: last.last_request_at_ms,
                last_id: last.session_id.clone(),
                ..cursor
            })?)
        } else {
            None
        };
        tx.commit()?;
        #[cfg(test)]
        if let Some(hook) = self.session_read_test_hook.lock().take() {
            hook(self);
        }
        check_visibility(&connection, visibility)?;
        Ok(ObservationSessionPageV2 {
            sessions,
            next_cursor,
        })
    }
}