#[derive(Debug, Clone, Default, PartialEq)]
pub struct ResponseMeta {
pub request_id: Option<String>,
pub latency_ms: Option<u64>,
pub trace_id: Option<String>,
pub cost: Option<f64>,
pub cost_status: Option<String>,
pub model: Option<String>,
pub input_tokens: Option<u64>,
pub output_tokens: Option<u64>,
pub total_tokens: Option<u64>,
pub cache_read_tokens: Option<u64>,
pub cache_write_tokens: Option<u64>,
pub limit_source: Option<String>,
pub budget_warning: Option<String>,
pub guardrails: Option<String>,
pub auth_reason: Option<String>,
pub response_cache: Option<String>,
pub response_cache_age: Option<u64>,
pub compression: Option<String>,
pub routing: Option<String>,
pub attempts: Option<u64>,
pub intent: Option<String>,
pub funding_source: Option<String>,
pub pot_fallback: Option<String>,
pub allowance_reset: Option<u64>,
pub model_deprecated: Option<bool>,
pub deprecation_notice: Option<String>,
}
pub const HEADER_NAMES: [&str; 26] = [
"x-nr-request-id",
"x-nr-latency-ms",
"x-nr-trace-id",
"x-nr-request-cost",
"x-nr-cost-status",
"x-nr-model",
"x-nr-input-tokens",
"x-nr-output-tokens",
"x-nr-total-tokens",
"x-nr-cache-read-tokens",
"x-nr-cache-write-tokens",
"x-nr-limit-source",
"x-nr-budget-warning",
"x-nr-guardrails",
"x-nr-auth-reason",
"x-nr-response-cache",
"x-nr-response-cache-age",
"x-nr-compression",
"x-nr-routing",
"x-nr-attempts",
"x-nr-intent",
"x-nr-funding-source",
"x-nr-pot-fallback",
"x-nr-allowance-reset",
"x-nr-model-deprecated",
"x-nr-deprecation-notice",
];
impl ResponseMeta {
pub fn from_lookup<F>(get: F) -> Self
where
F: Fn(&str) -> Option<String>,
{
let num = |name: &str| get(name).and_then(|v| v.parse::<u64>().ok());
let flag = |name: &str| match get(name).as_deref().map(str::trim) {
Some("true") => Some(true),
Some("false") => Some(false),
_ => None,
};
Self {
request_id: get("x-nr-request-id"),
latency_ms: num("x-nr-latency-ms"),
trace_id: get("x-nr-trace-id"),
cost: get("x-nr-request-cost").and_then(|v| v.parse::<f64>().ok()),
cost_status: get("x-nr-cost-status"),
model: get("x-nr-model"),
input_tokens: num("x-nr-input-tokens"),
output_tokens: num("x-nr-output-tokens"),
total_tokens: num("x-nr-total-tokens"),
cache_read_tokens: num("x-nr-cache-read-tokens"),
cache_write_tokens: num("x-nr-cache-write-tokens"),
limit_source: get("x-nr-limit-source"),
budget_warning: get("x-nr-budget-warning"),
guardrails: get("x-nr-guardrails"),
auth_reason: get("x-nr-auth-reason"),
response_cache: get("x-nr-response-cache"),
response_cache_age: num("x-nr-response-cache-age"),
compression: get("x-nr-compression"),
routing: get("x-nr-routing"),
attempts: num("x-nr-attempts"),
intent: get("x-nr-intent"),
funding_source: get("x-nr-funding-source"),
pot_fallback: get("x-nr-pot-fallback"),
allowance_reset: num("x-nr-allowance-reset"),
model_deprecated: flag("x-nr-model-deprecated"),
deprecation_notice: get("x-nr-deprecation-notice"),
}
}
pub fn from_headers(headers: &reqwest::header::HeaderMap) -> Self {
Self::from_lookup(|name| {
headers
.get(name)
.and_then(|v| v.to_str().ok())
.map(str::to_owned)
})
}
pub fn is_priced(&self) -> bool {
self.cost_status.as_deref() == Some("exact") && self.cost.is_some()
}
pub fn is_cache_hit(&self) -> bool {
self.response_cache.as_deref() == Some("hit")
}
pub fn is_cache_miss(&self) -> bool {
self.response_cache.as_deref() == Some("miss")
}
pub fn cache_age_seconds(&self) -> u64 {
self.response_cache_age.unwrap_or(0)
}
pub fn parse_budget_warning(&self) -> Option<BudgetWarningInfo> {
let warning = self.budget_warning.as_deref()?.trim();
let parts: Vec<&str> = warning.split_whitespace().collect();
if parts.len() != 3 || parts[1] != "soft_budget" {
return None;
}
let amounts: Vec<&str> = parts[2].split('/').collect();
if amounts.len() != 2 {
return None;
}
let spend = amounts[0].parse::<f64>().ok()?;
let ceiling = amounts[1].parse::<f64>().ok()?;
if spend.is_nan()
|| spend.is_infinite()
|| spend < 0.0
|| ceiling.is_nan()
|| ceiling.is_infinite()
|| ceiling <= 0.0
{
return None;
}
Some(BudgetWarningInfo {
scope: parts[0].to_string(),
spend,
ceiling,
})
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct BudgetWarningInfo {
pub scope: String,
pub spend: f64,
pub ceiling: f64,
}
pub fn extract_trace_headers(meta: &ResponseMeta) -> std::collections::HashMap<String, String> {
let mut out = std::collections::HashMap::new();
if let Some(ref req_id) = meta.request_id {
out.insert("x-nr-request-id".to_string(), req_id.clone());
}
out
}
pub fn with_trace_context(
headers: &std::collections::HashMap<String, String>,
trace_id: Option<&str>,
session_id: Option<&str>,
) -> Result<std::collections::HashMap<String, String>, crate::errors::NRouterError> {
if let Some(tid) = trace_id {
if tid.contains('\r') || tid.contains('\n') {
return Err(crate::errors::NRouterError::Configuration(
"trace_id must not contain CRLF characters".into(),
));
}
}
if let Some(sid) = session_id {
if sid.contains('\r') || sid.contains('\n') {
return Err(crate::errors::NRouterError::Configuration(
"session_id must not contain CRLF characters".into(),
));
}
}
let mut out = std::collections::HashMap::with_capacity(headers.len() + 2);
for (k, v) in headers {
if !v.contains('\r') && !v.contains('\n') {
out.insert(k.clone(), v.clone());
}
}
if let Some(tid) = trace_id {
out.insert("x-nr-trace-id".to_string(), tid.to_string());
}
if let Some(sid) = session_id {
out.insert("x-nr-session-id".to_string(), sid.to_string());
}
Ok(out)
}