Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

3.5 KB
Raw Blame
//! Per-provider-call pricing for speed tiers and long-context requests.

use super::{MeteringError, ModelSpeed};
use ai_usage::financial::{ProviderModel, UsageEvidence};
use ai_usage::{UsageAmount, UsageContext, UsageRecorder};
use serde_json::Value;
use std::sync::Arc;

#[derive(Clone)]
pub(super) struct PerCallUsage {
    recorder: Arc<dyn UsageRecorder>,
    usage: UsageContext,
    model: String,
    requested: ModelSpeed,
}

impl PerCallUsage {
    pub(super) fn new(
        recorder: Arc<dyn UsageRecorder>,
        usage: UsageContext,
        model: &str,
        requested: ModelSpeed,
    ) -> Self {
        Self {
            recorder,
            usage,
            model: model.to_owned(),
            requested,
        }
    }

    pub(super) fn matches(&self, model: &ProviderModel, body: &Value) -> bool {
        self.model == format!("{}/{}", model.provider(), model.model())
            && match self.requested {
                ModelSpeed::Standard => {
                    body.get("speed").is_none()
                        && body
                            .get("service_tier")
                            .is_none_or(|tier| tier == "default")
                }
                ModelSpeed::Fast => body.get("speed").is_some_and(|speed| speed == "fast"),
                ModelSpeed::Ultrafast => body
                    .get("service_tier")
                    .is_some_and(|tier| tier == "ultrafast"),
            }
    }

    pub(super) fn record(
        &self,
        evidence: UsageEvidence,
        delivered: Option<&str>,
    ) -> Result<(), MeteringError> {
        let UsageEvidence::Reported(tokens) = evidence else {
            return Ok(());
        };
        let speed = match delivered {
            Some("default" | "standard") => ModelSpeed::Standard,
            Some("fast") if self.model.starts_with("anthropic/") => ModelSpeed::Fast,
            Some("ultrafast") if self.model.starts_with("openai/") => ModelSpeed::Ultrafast,
            None if self.requested == ModelSpeed::Standard => ModelSpeed::Standard,
            _ => {
                tracing::error!(model = %self.model, "provider did not report a supported billing speed");
                return Err(MeteringError::Unsupported);
            }
        };
        if !speed.billable(&self.model) {
            return Err(MeteringError::Unsupported);
        }
        let bare = self
            .model
            .split_once('/')
            .ok_or(MeteringError::Unsupported)?
            .1;
        let mut price_key = bare.to_owned();
        match speed {
            ModelSpeed::Standard => {}
            ModelSpeed::Fast => price_key.push_str(":fast"),
            ModelSpeed::Ultrafast => price_key.push_str(":ultrafast"),
        }
        // OpenAI's threshold uses inclusive prompt tokens, per call, not the sum
        // of all prompts in a tool loop. Reasoning is billed as output once.
        if self.model.starts_with("openai/")
            && tokens
                .input()
                .saturating_add(tokens.cache_read())
                .saturating_add(tokens.cache_write())
                > 272_000
        {
            price_key.push_str(":long");
        }
        self.recorder.record(self.usage.clone().into_event(
            price_key,
            UsageAmount::Tokens {
                input: tokens.input(),
                output: tokens.output() + tokens.reasoning(),
                cache_read: tokens.cache_read(),
                cache_write: tokens.cache_write(),
            },
        ));
        Ok(())
    }
}

#[cfg(test)]
mod test;