CREATE TABLE spend_records (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    service TEXT NOT NULL,        -- e.g., "openai", "binance"
    date TEXT NOT NULL,           -- YYYY-MM-DD
    cost_usd REAL NOT NULL,       -- Dollar amount
    cost_micros INTEGER NOT NULL, -- USD * 1,000,000 (exact math)
    request_count INTEGER NOT NULL DEFAULT 1,
    created_at INTEGER NOT NULL   -- Unix timestamp
);

const USD_MICROS_SCALE: i64 = 1_000_000;

fn usd_f64_to_micros(usd: f64) -> Result<i64, SpendError> {
    if !usd.is_finite() || usd < 0.0 {
        return Err(SpendError::InvalidAmount(format!(
            "{usd} is not a valid non-negative finite USD amount"
        )));
    }
    let scaled = usd * USD_MICROS_SCALE as f64;
    let max_allowed = (i64::MAX as f64) - 0.5;
    if !scaled.is_finite() || scaled > max_allowed {
        return Err(SpendError::InvalidAmount(format!(
            "{usd} is outside supported range"
        )));
    }
    Ok(scaled.round() as i64)
}

curl -X PUT http://localhost:8473/api/spend/budgets \
  -H "Authorization: Bearer $SESSION_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "service": "openai",
    "daily_budget_usd": 50.0,
    "monthly_budget_usd": 1000.0
  }'

{
  "success": true,
  "budget": {
    "service": "openai",
    "daily_budget_usd": 50.0,
    "monthly_budget_usd": 1000.0,
    "updated_at": 1700000000
  }
}

CREATE TABLE service_budgets (
    service TEXT PRIMARY KEY,
    daily_budget_usd REAL NOT NULL,
    monthly_budget_usd REAL,
    updated_at INTEGER NOT NULL
);

pub struct ServiceBudget {
    pub service: String,
    pub daily_budget_usd: f64,
    pub monthly_budget_usd: Option<f64>,
    pub updated_at: i64,
}

#[tokio::test]
async fn test_binance_daily_volume_cap_enforced_under_concurrency() {
    // ... setup ...
    let req1 = Request::builder()
        .uri("/binance/api/v3/order")
        .body(Body::from("symbol=BTCUSDT&quoteOrderQty=10"));
    let req2 = Request::builder()
        .uri("/binance/api/v3/order")
        .body(Body::from("symbol=BTCUSDT&quoteOrderQty=10"));

    let (resp1, resp2) = tokio::join!(app.clone().oneshot(req1), app.clone().oneshot(req2));
    
    // One succeeds, one is denied
    let ok_count = statuses.iter().filter(|s| **s == StatusCode::OK).count();
    let forbidden_count = statuses.iter().filter(|s| **s == StatusCode::FORBIDDEN).count();
    assert_eq!(ok_count, 1);
    assert_eq!(forbidden_count, 1);
    
    // Exactly $10 spent (one request)
    let spent_today = state.spend_store.get_spent_today("binance").await.unwrap();
    assert!((spent_today - 10.0).abs() < 1e-9);
}

[llm.pricing]
gpt-4.input = 0.03  # per 1K tokens
gpt-4.output = 0.06
gpt-3.5-turbo.input = 0.001
gpt-3.5-turbo.output = 0.002

let order_value_usd = if let Some(qty) = params.get("quoteOrderQty") {
    qty.parse::<f64>().unwrap_or(0.0)
} else if let Some(qty) = params.get("quantity") {
    // Estimate from base quantity × price
    qty.parse::<f64>().unwrap_or(0.0) * estimated_price
} else {
    0.0
};

[custom.github]
base_url = "https://api.github.com"
cost_per_request_usd = 0.0  # Free API

pub async fn query_spend(&self, days: u32) -> Result<Vec<SpendRecord>, SpendError> {
    let cutoff = chrono::Utc::now()
        .date_naive()
        .checked_sub_days(chrono::Days::new(days as u64))
        .map(|d| d.format("%Y-%m-%d").to_string())
        .unwrap_or_default();

    let mut stmt = conn.prepare(
        "SELECT service, date, SUM(cost_usd) as total_cost, SUM(request_count) as total_requests
         FROM spend_records
         WHERE date >= ?1
         GROUP BY service, date
         ORDER BY date DESC, service ASC"
    )?;
    // ...
}

curl http://localhost:8473/api/spend?days=30 \
  -H "Authorization: Bearer $SESSION_TOKEN"

{
  "enabled": true,
  "daily": [
    {
      "service": "openai",
      "date": "2024-03-01",
      "cost_usd": 12.45,
      "request_count": 127
    },
    {
      "service": "anthropic",
      "date": "2024-03-01",
      "cost_usd": 5.23,
      "request_count": 43
    }
  ],
  "budgets": {
    "openai": {
      "daily_limit": 50.0,
      "spent_today": 12.45,
      "warning_pct": 80,
      "warning_active": false
    }
  }
}

pub async fn get_spent_today_micros(&self, service: &str) -> Result<i64, SpendError> {
    let today = chrono::Utc::now()
        .date_naive()
        .format("%Y-%m-%d")
        .to_string();
    let spent: i64 = conn.query_row(
        "SELECT COALESCE(SUM(cost_micros), 0) FROM spend_records WHERE service = ?1 AND date = ?2",
        params![service, today],
        |row| row.get(0),
    )?;
    Ok(spent)
}

let warning_active = config.llm.budget_warning_pct > 0
    && b.daily_budget_usd > 0.0
    && spent_today >= b.daily_budget_usd * (config.llm.budget_warning_pct as f64 / 100.0);

[llm]
budget_warning_pct = 80  # Alert at 80% of daily budget

pub async fn record_permit(&self, entry: &PermitEntry<'_>) -> Result<i64, SpendError> {
    conn.execute(
        "INSERT INTO onchain_permits (chain_id, target, value, status, reason, permit_hash, cost_usd, date, created_at)
         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)",
        params![chain_id, target, value, status, reason, permit_hash, cost_usd, today, now],
    )?;
}

while True:
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{"role": "user", "content": "Hello"}]
    )