Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
use super::*;
use crate::ModelSpeed;
use ai_usage::{UsageAmount, UsageEvent, UsageRecorder};
#[derive(Default)]
struct Recorder(Mutex<Vec<UsageEvent>>);
impl UsageRecorder for Recorder {
fn record(&self, event: UsageEvent) {
self.0.lock().unwrap().push(event);
}
}
#[tokio::test]
async fn responses_transport_prices_actual_tier_and_rejects_mismatched_request() {
let recorder = Arc::new(Recorder::default());
let context = MeteringContext::for_session(
recorder.clone(),
&UsageContext::new(
AiFeature::Chat,
"macro|[email protected]".to_owned().try_into().unwrap(),
),
"openai/gpt-6.1-sol",
ModelSpeed::Ultrafast,
)
.unwrap();
let transport = Transport::new(json!({"status":"completed", "service_tier":"ultrafast", "usage":{"input_tokens":100,"output_tokens":20,"input_tokens_details":{"cached_tokens":30},"output_tokens_details":{"reasoning_tokens":5}}}).to_string());
let client = MeteredHttpClient::new(transport.clone(), "openai", WireProtocol::Responses);
context
.scope(async {
for tier in ["ultrafast", "default"] {
let request = Request::builder()
.uri("https://example.test/responses")
.body(Bytes::from(
json!({"model":"gpt-6.1-sol","service_tier":tier}).to_string(),
))
.unwrap();
let result = client.send::<_, Bytes>(request).await;
assert_eq!(result.is_ok(), tier == "ultrafast");
}
})
.await;
assert_eq!(transport.calls.load(Ordering::SeqCst), 1);
let events = recorder.0.lock().unwrap();
assert_eq!(events.len(), 1);
assert_eq!(events[0].model, "gpt-6.1-sol:ultrafast");
assert!(matches!(
events[0].amount,
UsageAmount::Tokens {
input: 70,
output: 20,
cache_read: 30,
..
}
));
}
#[tokio::test]
async fn streaming_prices_completed_openai_and_claude_tiers_once() {
for (model, protocol, speed, body, wire, expected) in [
(
"openai/gpt-6-astra",
WireProtocol::Responses,
ModelSpeed::Ultrafast,
json!({"model":"gpt-6-astra","service_tier":"ultrafast"}),
"data: {\"type\":\"response.completed\",\"response\":{\"service_tier\":\"ultrafast\",\"usage\":{\"input_tokens\":10,\"output_tokens\":20}}}\n\n",
"gpt-6-astra:ultrafast",
),
(
"anthropic/claude-opus-5-5",
WireProtocol::Anthropic,
ModelSpeed::Fast,
json!({"model":"claude-opus-5-5","speed":"fast"}),
"data: {\"type\":\"message_start\",\"message\":{\"usage\":{\"speed\":\"fast\",\"input_tokens\":10,\"output_tokens\":1,\"cache_read_input_tokens\":5,\"cache_creation_input_tokens\":3}}}\n\ndata: {\"type\":\"message_delta\",\"usage\":{\"output_tokens\":20}}\n\ndata: {\"type\":\"message_stop\"}\n\n",
"claude-opus-5-5:fast",
),
(
"anthropic/claude-opus-5-5",
WireProtocol::Anthropic,
ModelSpeed::Fast,
json!({"model":"claude-opus-5-5","speed":"fast"}),
"data: {\"type\":\"message_start\",\"message\":{\"usage\":{\"speed\":\"standard\",\"input_tokens\":10,\"output_tokens\":1}}}\n\ndata: {\"type\":\"message_delta\",\"usage\":{\"output_tokens\":20}}\n\ndata: {\"type\":\"message_stop\"}\n\n",
"claude-opus-5-5",
),
] {
let recorder = Arc::new(Recorder::default());
let context = MeteringContext::for_session(
recorder.clone(),
&UsageContext::system(AiFeature::Chat),
model,
speed,
)
.unwrap();
let provider = model.split_once('/').unwrap().0;
let transport = Transport::new(wire);
let client = MeteredHttpClient::new(transport.clone(), provider, protocol);
context
.scope(async {
let request = Request::builder()
.uri("https://example.test/api")
.header("anthropic-beta", "existing-beta")
.body(Bytes::from(body.to_string()))
.unwrap();
let mut stream = client.send_streaming(request).await.unwrap().into_body();
while let Some(chunk) = stream.next().await {
chunk.unwrap();
}
})
.await;
let events = recorder.0.lock().unwrap();
assert_eq!(events.len(), 1);
assert_eq!(events[0].model, expected);
assert!(matches!(
events[0].amount,
UsageAmount::Tokens {
input: 10,
output: 20,
..
}
));
if expected.ends_with(":fast") {
assert!(matches!(
events[0].amount,
UsageAmount::Tokens {
cache_read: 5,
cache_write: 3,
..
}
));
}
if provider == "anthropic" {
let headers = transport.headers.lock().unwrap();
let beta = headers[0]["anthropic-beta"].to_str().unwrap();
assert!(beta.contains("existing-beta"));
assert!(beta.contains("fast-mode-2026-02-01"));
}
}
}
#[tokio::test]
async fn child_completion_does_not_inherit_parent_speed_pricing() {
let recorder = Arc::new(Recorder::default());
let usage = UsageContext::system(AiFeature::Chat);
let parent = MeteringContext::for_session(
recorder.clone(),
&usage,
"openai/gpt-6-astra",
ModelSpeed::Ultrafast,
)
.unwrap();
let transport = Transport::new(anthropic_response());
let client = MeteredHttpClient::new(transport.clone(), "anthropic", WireProtocol::Anthropic);
parent
.scope(async {
let child = MeteringContext::for_operation(recorder.as_ref(), &usage);
MeteringContext::carry(child, async {
client
.send::<_, Bytes>(request())
.await
.unwrap()
.into_body()
.await
.unwrap();
})
.await;
})
.await;
assert_eq!(transport.calls.load(Ordering::SeqCst), 1);
assert!(recorder.0.lock().unwrap().is_empty());
}
#[tokio::test]
async fn missing_delivered_tier_preserves_legacy_provider_results() {
for (protocol, model, speed, request_body, response) in [
(
WireProtocol::Responses,
"openai/gpt-6-astra",
ModelSpeed::Ultrafast,
json!({"model":"gpt-6-astra","service_tier":"ultrafast"}),
json!({"status":"completed","usage":{"input_tokens":10,"output_tokens":20}}),
),
(
WireProtocol::Anthropic,
"anthropic/claude-opus-5-5",
ModelSpeed::Fast,
json!({"model":"claude-opus-5-5","speed":"fast"}),
json!({"usage":{"input_tokens":10,"output_tokens":20}}),
),
] {
let recorder = Arc::new(Recorder::default());
let context = MeteringContext::for_session(
recorder.clone(),
&UsageContext::system(AiFeature::Chat),
model,
speed,
)
.unwrap();
let provider = model.split_once('/').unwrap().0;
let client =
MeteredHttpClient::new(Transport::new(response.to_string()), provider, protocol);
context
.scope(async {
let request = Request::builder()
.uri("https://example.test/api")
.body(Bytes::from(request_body.to_string()))
.unwrap();
let delivered = client.send::<_, Bytes>(request).await.unwrap();
assert_eq!(
delivered.into_body().await.unwrap(),
Bytes::from(response.to_string())
);
})
.await;
assert!(recorder.0.lock().unwrap().is_empty());
}
}