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.

10.7 KB
Raw Blame
use super::{ingest::RawUsage, *};
use crate::LocalObservationStore;
use hiroute_domain::{
    ExecutionPricingEvidenceV1, InputUsageMeaningV1, OutputUsageMeaningV1, PriceValuationKindV1,
    UsageFrameKindV1,
};
use rusqlite::{OptionalExtension, params};
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;

type ValuationRequestMetadata = (u64, String, bool, bool, i64, Option<String>, Option<u64>);

#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct ValuationAmountV2 {
    pub currency: String,
    pub valuation_kind: PriceValuationKindV1,
    pub known_sum_micros: Option<u64>,
    pub coverage: MetricCoverage,
    pub missing_attempt_count: u64,
}

#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct ValuationRecordV2 {
    pub algorithm: String,
    pub input_revision: u64,
    pub input_digest: String,
    pub supersedes: Option<u64>,
    pub terminal_observed: bool,
    pub facts_partial: bool,
    pub unknown_attempt_count: u64,
    pub attempts: Vec<AttemptValuationV2>,
    pub amounts: Vec<ValuationAmountV2>,
    #[serde(default)]
    pub reference_comparison: Option<ReferenceComparisonV2>,
}

impl LocalObservationStore {
    /// One maintenance worker calls this bounded cycle. Input and result updates
    /// use the same writer transaction; retries cannot double-add contributions.
    pub fn settle_pending_valuations(&self, limit: usize) -> Result<usize, ValuationError> {
        if limit == 0 || limit > 200 {
            return Err(ValuationError::InvalidInput);
        }
        let mut connection = self.connection.lock();
        let transaction = connection.transaction()?;
        let pending = {
            let mut statement=transaction.prepare("SELECT workspace_id,request_id FROM valuation_pending_v2 ORDER BY workspace_id,request_id LIMIT ?1")?;
            statement
                .query_map([limit], |row| {
                    Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
                })?
                .collect::<Result<Vec<_>, _>>()?
        };
        for (workspace, request) in &pending {
            settle_one(&transaction, workspace, request)?;
            transaction.execute(
                "DELETE FROM valuation_pending_v2 WHERE workspace_id=?1 AND request_id=?2",
                params![workspace, request],
            )?;
        }
        let now_ms = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .ok()
            .and_then(|n| i64::try_from(n.as_millis()).ok())
            .unwrap_or(0);
        crate::analysis::sync(&transaction, 200, now_ms)?;
        transaction.commit()?;
        Ok(pending.len())
    }
}

pub(super) fn settle_one(
    transaction: &rusqlite::Transaction<'_>,
    workspace: &str,
    request: &str,
) -> Result<(), ValuationError> {
    let metadata:Option<ValuationRequestMetadata>=transaction.query_row(
        "SELECT input_revision,input_digest,terminal,partial,started_ms,plan_id,accepted_ordinal FROM valuation_requests_v2 WHERE workspace_id=?1 AND request_id=?2",
        params![workspace,request],|row|Ok((row.get(0)?,row.get(1)?,row.get(2)?,row.get(3)?,row.get(4)?,row.get(5)?,row.get(6)?)),
    ).optional()?;
    let Some((revision, digest, terminal, partial, started, plan, accepted_ordinal)) = metadata
    else {
        return Ok(());
    };
    let previous:Option<(u64,String)>=transaction.query_row(
        "SELECT revision,input_digest FROM valuation_records_v2 WHERE workspace_id=?1 AND request_id=?2 ORDER BY revision DESC LIMIT 1",
        params![workspace,request],|row|Ok((row.get(0)?,row.get(1)?)),
    ).optional()?;
    if previous.as_ref().is_some_and(|(_, old)| old == &digest) {
        return Ok(());
    }
    let inputs = {
        let mut statement=transaction.prepare("SELECT pricing_json,usage_json,ordinal FROM valuation_attempt_inputs_v2 WHERE workspace_id=?1 AND request_id=?2 ORDER BY ordinal LIMIT 257")?;
        statement
            .query_map(params![workspace, request], |row| {
                Ok((
                    row.get::<_, Option<String>>(0)?,
                    row.get::<_, Option<String>>(1)?,
                    row.get::<_, u64>(2)?,
                ))
            })?
            .collect::<Result<Vec<_>, _>>()?
    };
    let truncated = inputs.len() > 256;
    let mut record = ValuationRecordV2 {
        algorithm: VALUATION_ALGORITHM.into(),
        input_revision: revision,
        input_digest: digest.clone(),
        supersedes: previous.map(|(revision, _)| revision),
        terminal_observed: terminal,
        facts_partial: partial || truncated,
        unknown_attempt_count: u64::from(truncated),
        attempts: vec![],
        amounts: vec![],
        reference_comparison: None,
    };
    let mut reference_input = None;
    for (pricing, usage, ordinal) in inputs.into_iter().take(256) {
        let pricing = match pricing
            .map(|json| serde_json::from_str::<ExecutionPricingEvidenceV1>(&json))
            .transpose()
        {
            Ok(value) => value,
            Err(_) => {
                record.unknown_attempt_count += 1;
                record.facts_partial = true;
                continue;
            }
        };
        let Some(pricing) = pricing else {
            record.unknown_attempt_count += 1;
            continue;
        };
        let Some(quote) = &pricing.quote else {
            record.unknown_attempt_count += 1;
            continue;
        };
        let raw = match usage
            .map(|json| serde_json::from_str::<RawUsage>(&json))
            .transpose()
        {
            Ok(value) => value.unwrap_or_default(),
            Err(_) => {
                record.unknown_attempt_count += 1;
                record.facts_partial = true;
                continue;
            }
        };
        let usage = normalize(&pricing, &raw);
        if accepted_ordinal == Some(ordinal) {
            reference_input = pricing
                .reference_quote
                .clone()
                .map(|reference| (reference, usage.clone()));
        }
        match value_attempt(quote, &usage) {
            Ok(attempt) => record.attempts.push(attempt),
            Err(_) => {
                record.unknown_attempt_count += 1;
                record.facts_partial = true;
            }
        }
    }
    let mut groups: BTreeMap<(String, PriceValuationKindV1), ValuationAmountV2> = BTreeMap::new();
    let mut overflowed = std::collections::BTreeSet::new();
    for attempt in &record.attempts {
        let key = (attempt.currency.clone(), attempt.valuation_kind);
        let group = groups
            .entry((attempt.currency.clone(), attempt.valuation_kind))
            .or_insert_with(|| ValuationAmountV2 {
                currency: attempt.currency.clone(),
                valuation_kind: attempt.valuation_kind,
                known_sum_micros: None,
                coverage: MetricCoverage::Complete,
                missing_attempt_count: record.unknown_attempt_count,
            });
        if attempt
            .components
            .iter()
            .any(|component| component.missing == Some(ValuationMissingReason::ArithmeticOverflow))
        {
            overflowed.insert(key.clone());
        }
        if !overflowed.contains(&key)
            && let Some(amount) = attempt.known_sum_micros
        {
            group.known_sum_micros = group
                .known_sum_micros
                .unwrap_or(0)
                .checked_add(amount)
                .filter(|sum| *sum <= i64::MAX as u64);
            if group.known_sum_micros.is_none() {
                overflowed.insert(key.clone());
            }
        }
        if overflowed.contains(&key) {
            group.known_sum_micros = None;
        }
        if attempt.coverage != MetricCoverage::Complete {
            group.missing_attempt_count += 1;
        }
        if group.known_sum_micros.is_none() {
            group.coverage = MetricCoverage::Unknown;
        } else if group.missing_attempt_count > 0 || record.facts_partial || !terminal {
            group.coverage = MetricCoverage::Partial;
        }
    }
    record.amounts = groups.into_values().collect();
    if let Some((reference, usage)) = reference_input {
        record.reference_comparison = Some(compare_reference(
            &reference,
            &usage,
            &record.attempts,
            terminal && !record.facts_partial && record.unknown_attempt_count == 0,
        )?);
    }
    let body = serde_json::to_string(&record).map_err(|_| ValuationError::InvalidEvidence)?;
    transaction.execute("INSERT INTO valuation_records_v2(workspace_id,request_id,revision,input_digest,body_json) VALUES(?1,?2,?3,?4,?5)",
        params![workspace,request,revision,digest,body])?;
    // Replace active contributions in the same commit as the new revision.
    transaction.execute(
        "DELETE FROM valuation_contributions_v2 WHERE workspace_id=?1 AND request_id=?2",
        params![workspace, request],
    )?;
    for amount in &record.amounts {
        transaction.execute("INSERT INTO valuation_contributions_v2(workspace_id,request_id,day,plan_id,currency,valuation_kind,known_micros,coverage)
            VALUES(?1,?2,?3,?4,?5,?6,?7,?8)",params![workspace,request,started/86_400_000,plan,amount.currency,
                serde_json::to_string(&amount.valuation_kind).map_err(|_|ValuationError::InvalidEvidence)?,amount.known_sum_micros,
                serde_json::to_string(&amount.coverage).map_err(|_|ValuationError::InvalidEvidence)?])?;
    }
    Ok(())
}

pub(crate) fn normalize(pricing: &ExecutionPricingEvidenceV1, raw: &RawUsage) -> UsageBucketsV2 {
    normalize_semantics(pricing.usage_semantics, raw)
}
pub(crate) fn normalize_semantics(
    semantics: hiroute_domain::UsageSemanticsV1,
    raw: &RawUsage,
) -> UsageBucketsV2 {
    if semantics.frame_kind == UsageFrameKindV1::Unknown {
        return UsageBucketsV2::default();
    }
    let output = match semantics.output {
        OutputUsageMeaningV1::IncludesReasoning => raw.output,
        OutputUsageMeaningV1::ReasoningSeparatelyAtOutputRate => raw
            .output
            .zip(raw.reasoning)
            .and_then(|(a, b)| a.checked_add(b)),
        OutputUsageMeaningV1::Unknown => None,
    };
    let (read, write) = if semantics.cache_buckets_exclusive {
        (raw.read, raw.write)
    } else {
        (None, None)
    };
    match semantics.input {
        InputUsageMeaningV1::IncludesExclusiveCache => {
            UsageBucketsV2::from_inclusive_input(raw.input, output, read, write)
        }
        InputUsageMeaningV1::UncachedOnly => UsageBucketsV2 {
            input_uncached: raw.input,
            output,
            cache_read: read,
            cache_write: write,
        },
        InputUsageMeaningV1::Unknown => UsageBucketsV2 {
            output,
            ..UsageBucketsV2::default()
        },
    }
}