# Cost is calculated automatically for every trace
with client.start_as_current_generation(name="chat", model="gpt-4o") as gen:
    response = openai.chat.completions.create(...)
    # Cost automatically recorded:
    # input_tokens × input_price + output_tokens × output_price

┌─────────────────────────────────────────────────────────────────┐
│                    Cost Analytics                                │
├─────────────────────────────────────────────────────────────────┤
│  This Month: $2,450.32                                          │
│  Projected: $2,890.00                                           │
│  Budget: $3,000.00 (97% used)                                   │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Daily Spending                                                  │
│  ████████████████████████  $95.20                               │
│  ██████████████████████    $88.50                               │
│  ████████████████████████████  $102.30                          │
│  ██████████████████          $78.90                             │
│                                                                  │
├─────────────────────────────────────────────────────────────────┤
│  Cost by Model              │  Cost by Feature                  │
│  GPT-4o: $1,800 (73%)       │  Chat: $1,500 (61%)               │
│  GPT-4o-mini: $450 (18%)    │  Search: $650 (27%)               │
│  Claude Sonnet: $200 (9%)   │  Summary: $300 (12%)              │
└─────────────────────────────────────────────────────────────────┘

costs_by_model = client.analytics.get_costs(group_by="model")
# GPT-4o: $1,800
# GPT-4o-mini: $450
# Claude Sonnet: $200

with client.start_as_current_span(name="search") as span:
    span.update_trace(metadata={"feature": "search"})
    response = llm.generate(search_prompt)

# Later: Get costs by feature
costs_by_feature = client.analytics.get_costs(
    group_by="metadata.feature"
)

with client.start_as_current_span(name="chat") as span:
    span.update_trace(
        user_id="user_123",
        metadata={"user_tier": "enterprise"}
    )
    response = llm.generate(prompt)

# Costs by user tier
costs_by_tier = client.analytics.get_costs(
    group_by="metadata.user_tier"
)
# enterprise: $1,200
# pro: $800
# free: $450

# Daily costs
daily_costs = client.analytics.get_costs(
    start_time=datetime.now() - timedelta(days=30),
    group_by="day"
)

# Hourly costs (for finding peak usage)
hourly_costs = client.analytics.get_costs(
    start_time=datetime.now() - timedelta(hours=24),
    group_by="hour"
)

# Set monthly budget
client.projects.update(
    project_id="proj_123",
    settings={
        "budget": {
            "monthly_limit": 3000,
            "alert_thresholds": [0.5, 0.8, 0.95]  # 50%, 80%, 95%
        }
    }
)

# Create cost alert
client.alerts.create(
    name="Daily cost exceeded",
    condition="daily_cost > 150",
    channels=["slack", "email"],
    message="Daily AI spending exceeded $150"
)

# Budget percentage alert
client.alerts.create(
    name="Budget warning",
    condition="monthly_cost > (monthly_budget * 0.8)",
    channels=["email"],
    message="80% of monthly budget used"
)

# Spike detection
client.alerts.create(
    name="Cost spike",
    condition="daily_cost > (avg_daily_cost_7d * 2)",
    channels=["slack"],
    message="Cost spike: spending 2x normal rate"
)

# Per-user cost
client.alerts.create(
    name="High user cost",
    condition="cost_per_user > 10",
    channels=["email"],
    message="User exceeding $10 in AI costs"
)

def select_model(task_type: str, importance: str) -> str:
    """Select cost-effective model based on task."""
    if task_type == "classification" or importance == "low":
        return "gpt-4o-mini"  # $0.15/1M input
    elif task_type == "reasoning" and importance == "high":
        return "gpt-4o"  # $2.50/1M input
    else:
        return "gpt-4o-mini"

# Use in application
model = select_model(task_type="summarization", importance="medium")

# 1. Trim unnecessary context
def optimize_context(context: str, max_chars: int = 8000) -> str:
    if len(context) > max_chars:
        # Keep most relevant parts
        return context[:max_chars]
    return context

# 2. Use efficient prompts
EFFICIENT_PROMPT = "Summarize in 2 sentences:"
VERBOSE_PROMPT = "Please provide a comprehensive summary..."

# 3. Set appropriate max_tokens
response = openai.chat.completions.create(
    model="gpt-4o-mini",
    messages=messages,
    max_tokens=150  # Limit output length
)

import hashlib

def get_cached_response(prompt: str, cache: dict) -> str | None:
    key = hashlib.sha256(prompt.encode()).hexdigest()
    return cache.get(key)

def cache_response(prompt: str, response: str, cache: dict):
    key = hashlib.sha256(prompt.encode()).hexdigest()
    cache[key] = response

# Use semantic caching for similar queries
# (Brokle can help identify similar queries via embeddings)

# Instead of 10 individual calls
for item in items:
    response = llm.generate(f"Classify: {item}")

# Batch into single call
all_items = "\n".join([f"{i}. {item}" for i, item in enumerate(items)])
response = llm.generate(f"Classify each item:\n{all_items}")

# Tag traces with user
with client.start_as_current_span(name="chat") as span:
    span.update_trace(user_id="user_123")
    response = llm.generate(prompt)

# Query user costs
user_costs = client.analytics.get_costs(
    filters={"user_id": "user_123"},
    start_time=datetime.now() - timedelta(days=30)
)

print(f"User 123 cost: ${user_costs.total:.2f}")

# Tag traces with feature
with client.start_as_current_span(name="search") as span:
    span.update_trace(metadata={"feature": "ai_search"})

# Compare feature costs
features = ["chat", "search", "summarization", "analysis"]
for feature in features:
    cost = client.analytics.get_costs(
        filters={"metadata.feature": feature}
    )
    print(f"{feature}: ${cost.total:.2f}")

# Generate monthly report
report = client.analytics.generate_report(
    report_type="cost_summary",
    period="monthly",
    include=[
        "total_cost",
        "cost_by_model",
        "cost_by_feature",
        "cost_trend",
        "optimization_suggestions"
    ]
)

# Export to PDF
report.export("pdf", "cost_report_december.pdf")

# Send via email
report.email(
    recipients=["finance@company.com"],
    subject="Monthly AI Cost Report"
)

client.reports.schedule(
    name="Weekly Cost Summary",
    report_type="cost_summary",
    schedule="weekly",
    day="monday",
    recipients=["team@company.com"]
)

client.pricing.set_custom_price(
    model="llama-3-70b",
    input_price_per_million=0.50,
    output_price_per_million=0.75
)

client.pricing.set_discount(
    provider="openai",
    discount_percent=20  # 20% off all OpenAI models
)

# Always include attribution metadata
with client.start_as_current_span(name="operation") as span:
    span.update_trace(
        user_id=user_id,
        metadata={
            "feature": feature_name,
            "team": team_name,
            "environment": "production"
        }
    )

# Don't wait for a surprise bill
client.alerts.create(
    name="Cost protection",
    condition="daily_cost > 200",
    channels=["email", "slack"],
    message="Daily cost exceeded $200"
)