aix-rs 1.0.0

Manage AI gateway profiles and launch AI coding tools with the right credentials
use super::json_usage::JsonUsageFieldExtractor;
use super::sse::{SseDecoder, SseFrame};
use crate::local_gateway::{ResponseBodyObserver, ResponseStreamEnd};
use crate::usage_event::{TokenUsage, UsageEventRecorder, UsageOutcome};
use serde::Deserialize;

#[derive(Debug, Deserialize)]
struct AnthropicUsageRaw {
    input_tokens: Option<u64>,
    output_tokens: Option<u64>,
    cache_creation_input_tokens: Option<u64>,
    cache_read_input_tokens: Option<u64>,
}

#[derive(Debug, Deserialize)]
struct AnthropicEnvelope {
    usage: Option<AnthropicUsageRaw>,
    message: Option<AnthropicMessage>,
    #[serde(rename = "type")]
    event_type: Option<String>,
}

#[derive(Debug, Deserialize)]
struct AnthropicMessage {
    usage: Option<AnthropicUsageRaw>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum TerminalEvent {
    Stopped,
    Failed,
}

#[derive(Default)]
struct AnthropicSseUsage {
    decoder: SseDecoder,
    usage: TokenUsage,
    terminal: Option<TerminalEvent>,
}

impl AnthropicSseUsage {
    fn push(&mut self, bytes: &[u8]) {
        let (decoder, usage, terminal) = (&mut self.decoder, &mut self.usage, &mut self.terminal);
        decoder.push(bytes, |frame| {
            observe_anthropic_frame(frame, usage, terminal)
        });
    }

    fn finish(&mut self) {
        let (decoder, usage, terminal) = (&mut self.decoder, &mut self.usage, &mut self.terminal);
        decoder.finish(|frame| observe_anthropic_frame(frame, usage, terminal));
    }
}

fn observe_anthropic_frame(
    frame: SseFrame,
    usage: &mut TokenUsage,
    terminal: &mut Option<TerminalEvent>,
) {
    let frame_type = frame.event.as_deref();
    match frame_type {
        Some("message_stop") => *terminal = Some(TerminalEvent::Stopped),
        Some("error") => *terminal = Some(TerminalEvent::Failed),
        _ => {}
    }
    let Ok(envelope) = serde_json::from_slice::<AnthropicEnvelope>(&frame.data) else {
        return;
    };
    if let Some(event_type) = envelope.event_type.as_deref() {
        match event_type {
            "message_stop" => *terminal = Some(TerminalEvent::Stopped),
            "error" => *terminal = Some(TerminalEvent::Failed),
            _ => {}
        }
    }
    let event_type = frame_type.or(envelope.event_type.as_deref());
    let update = match event_type {
        Some("message_start") => envelope.message.and_then(|message| message.usage),
        Some("message_delta") => envelope.usage,
        _ => envelope.usage,
    };
    if let Some(mut update) = update.map(normalize_anthropic_usage) {
        if event_type == Some("message_start") {
            update.output_tokens = None;
            update.total_tokens = None;
        }
        usage.merge(&update);
    }
}

pub(crate) fn messages_json_usage(body: &[u8]) -> Option<TokenUsage> {
    serde_json::from_slice::<AnthropicEnvelope>(body)
        .ok()?
        .usage
        .map(normalize_anthropic_usage)
}

pub(crate) fn messages_sse_usage<'a>(
    chunks: impl IntoIterator<Item = &'a [u8]>,
) -> Option<TokenUsage> {
    let mut stream = AnthropicSseUsage::default();
    for chunk in chunks {
        stream.push(chunk);
    }
    stream.finish();
    (stream.usage.completeness() != crate::usage_event::UsageCompleteness::Unavailable)
        .then_some(stream.usage)
}

pub(crate) struct AnthropicMessagesObserver {
    stream: AnthropicSseUsage,
    recorder: Option<UsageEventRecorder>,
    status: u16,
    is_sse: bool,
    json_usage: JsonUsageFieldExtractor,
    finished: bool,
}

impl AnthropicMessagesObserver {
    pub(crate) fn new(recorder: UsageEventRecorder, status: u16, is_sse: bool) -> Self {
        Self {
            stream: AnthropicSseUsage::default(),
            recorder: Some(recorder),
            status,
            is_sse,
            json_usage: JsonUsageFieldExtractor::new(false),
            finished: false,
        }
    }
}

impl ResponseBodyObserver for AnthropicMessagesObserver {
    fn observe(&mut self, bytes: &[u8]) {
        if self.is_sse {
            self.stream.push(bytes);
        } else {
            self.json_usage.push(bytes);
        }
        if let Some(recorder) = &mut self.recorder {
            recorder.set_usage(&self.stream.usage);
        }
    }

    fn finish(&mut self, stream_end: ResponseStreamEnd) {
        if self.is_sse {
            self.stream.finish();
        } else {
            self.json_usage.finish();
            if let Some(usage) = self
                .json_usage
                .root_usage()
                .and_then(|bytes| serde_json::from_slice::<AnthropicUsageRaw>(bytes).ok())
                .map(normalize_anthropic_usage)
            {
                self.stream.usage.merge(&usage);
            }
        }
        let (outcome, category) = if !(200..300).contains(&self.status) {
            (UsageOutcome::Failed, Some("upstream_http"))
        } else if matches!(self.stream.terminal, Some(TerminalEvent::Failed)) {
            (UsageOutcome::Failed, Some("upstream_response_error"))
        } else if matches!(stream_end, ResponseStreamEnd::Error) {
            (UsageOutcome::Failed, Some("upstream_stream"))
        } else if !self.is_sse {
            (UsageOutcome::Succeeded, None)
        } else {
            match self.stream.terminal {
                Some(TerminalEvent::Stopped) => (UsageOutcome::Succeeded, None),
                _ => (
                    UsageOutcome::Incomplete,
                    Some("stream_ended_without_message_stop"),
                ),
            }
        };
        if let Some(mut recorder) = self.recorder.take() {
            recorder.set_usage(&self.stream.usage);
            recorder.finish(outcome, Some(self.status), category);
        }
        self.finished = true;
    }
}

impl Drop for AnthropicMessagesObserver {
    fn drop(&mut self) {
        if !self.finished {
            if let Some(mut recorder) = self.recorder.take() {
                recorder.set_usage(&self.stream.usage);
                let category = if (200..300).contains(&self.status) {
                    "stream_terminated"
                } else {
                    "upstream_http"
                };
                recorder.finish(UsageOutcome::Failed, Some(self.status), Some(category));
            }
        }
    }
}

fn normalize_anthropic_usage(raw: AnthropicUsageRaw) -> TokenUsage {
    let input_tokens_total = raw.input_tokens.and_then(|input| {
        input
            .checked_add(raw.cache_creation_input_tokens.unwrap_or_default())?
            .checked_add(raw.cache_read_input_tokens.unwrap_or_default())
    });
    TokenUsage::canonical(
        input_tokens_total,
        raw.input_tokens,
        raw.cache_read_input_tokens,
        raw.cache_creation_input_tokens,
        raw.output_tokens,
        None,
    )
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::local_gateway::LaunchContext;
    use crate::usage_event::UsageCompleteness;
    use crate::usage_store::{UsageEventFilter, UsageStore};
    use assert_fs::TempDir;

    #[test]
    fn messages_usage_includes_cache_counters_in_total_input_exactly_once() {
        let usage = messages_json_usage(
            br#"{"id":"msg-secret","content":[{"text":"private response"}],"usage":{"input_tokens":10,"cache_creation_input_tokens":3,"cache_read_input_tokens":5,"output_tokens":7}}"#,
        )
        .unwrap();

        assert_eq!(usage.input_tokens_total, Some(18));
        assert_eq!(usage.input_tokens_uncached, Some(10));
        assert_eq!(usage.cache_read_input_tokens, Some(5));
        assert_eq!(usage.cache_write_input_tokens, Some(3));
        assert_eq!(usage.total_tokens, Some(25));
        assert_eq!(usage.completeness(), UsageCompleteness::Complete);
    }

    #[test]
    fn messages_sse_merges_start_cache_usage_and_cumulative_output_usage() {
        let mut stream = AnthropicSseUsage::default();
        let bytes = b"event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"usage\":{\"input_tokens\":8,\"cache_creation_input_tokens\":2,\"cache_read_input_tokens\":4,\"output_tokens\":0}}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"delta\":{\"text\":\"never persist this\"}}\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"usage\":{\"output_tokens\":9}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n";
        for chunk in bytes.chunks(7) {
            stream.push(chunk);
        }
        stream.finish();

        assert_eq!(stream.usage.input_tokens_total, Some(14));
        assert_eq!(stream.usage.input_tokens_uncached, Some(8));
        assert_eq!(stream.usage.cache_read_input_tokens, Some(4));
        assert_eq!(stream.usage.cache_write_input_tokens, Some(2));
        assert_eq!(stream.usage.output_tokens, Some(9));
        assert_eq!(stream.usage.total_tokens, Some(23));
        assert_eq!(stream.terminal, Some(TerminalEvent::Stopped));
    }

    #[test]
    fn messages_sse_helper_preserves_cumulative_usage_across_arbitrary_chunks() {
        let bytes = b"event: message_start\ndata: {\"message\":{\"usage\":{\"input_tokens\":4,\"cache_read_input_tokens\":2}}}\n\nevent: message_delta\ndata: {\"usage\":{\"output_tokens\":5}}\n\nevent: message_stop\ndata: {}\n\n";
        let usage = messages_sse_usage(bytes.chunks(4)).unwrap();

        assert_eq!(usage.input_tokens_total, Some(6));
        assert_eq!(usage.cache_read_input_tokens, Some(2));
        assert_eq!(usage.output_tokens, Some(5));
        assert_eq!(usage.total_tokens, Some(11));
    }

    #[test]
    fn non_sse_usage_extracts_cache_counters_across_chunk_splits_without_content() {
        let state = TempDir::new().unwrap();
        let store = UsageStore::new(state.path());
        let body = format!(
            r#"{{"content":[{{"type":"text","text":"ANTHROPIC_RESPONSE_MARKER_DO_NOT_PERSIST{}"}},{{"type":"tool_use","input":{{"private":"TOOL_INPUT_MARKER_DO_NOT_PERSIST"}}}}],"usage":{{"input_tokens":11,"cache_creation_input_tokens":3,"cache_read_input_tokens":5,"output_tokens":7}}}}"#,
            "z".repeat(64 * 1024)
        );
        let context = LaunchContext::new("work".to_string(), "claude".to_string(), None, None);
        let recorder = UsageEventRecorder::new(Some(store.clone()), &context, "anthropic_messages");
        let mut observer = AnthropicMessagesObserver::new(recorder, 200, false);
        let mut offset = 0;
        let mut chunk_size = 1;
        while offset < body.len() {
            let end = (offset + chunk_size).min(body.len());
            observer.observe(&body.as_bytes()[offset..end]);
            offset = end;
            chunk_size = (chunk_size * 11 % 37).max(1);
        }
        observer.finish(ResponseStreamEnd::Complete);

        let events = store
            .events(&UsageEventFilter {
                start_unix_ms: 0,
                end_unix_ms: u64::MAX,
                ..UsageEventFilter::default()
            })
            .unwrap();
        assert_eq!(events.len(), 1);
        assert_eq!(events[0].input_tokens_total, Some(19));
        assert_eq!(events[0].input_tokens_uncached, Some(11));
        assert_eq!(events[0].cache_read_input_tokens, Some(5));
        assert_eq!(events[0].cache_write_input_tokens, Some(3));
        assert_eq!(events[0].output_tokens, Some(7));
        assert_eq!(events[0].total_tokens, Some(26));
        assert_eq!(events[0].usage_completeness, UsageCompleteness::Complete);
        assert_eq!(events[0].outcome, UsageOutcome::Succeeded);
        let event_dir = std::fs::read_dir(state.path().join("usage/events"))
            .unwrap()
            .next()
            .unwrap()
            .unwrap()
            .path();
        let persisted = std::fs::read_to_string(
            std::fs::read_dir(event_dir)
                .unwrap()
                .next()
                .unwrap()
                .unwrap()
                .path(),
        )
        .unwrap();
        assert!(!persisted.contains("ANTHROPIC_RESPONSE_MARKER_DO_NOT_PERSIST"));
        assert!(!persisted.contains("TOOL_INPUT_MARKER_DO_NOT_PERSIST"));
    }
}