tracker := sdk.NewCostTracker(logger, metrics)

// Track a request
tracker.TrackRequest(ctx, sdk.CostEntry{
    Model:        "gpt-4",
    InputTokens:  100,
    OutputTokens: 200,
    Provider:     "openai",
})

// Get total cost
total := tracker.GetTotalCost()
fmt.Printf("Total spent: $%.2f\n", total)

tracker := sdk.NewCostTracker(logger, metrics)

// Set monthly budget
tracker.SetMonthlyBudget(1000.00)  // $1000/month

// Set alert threshold
tracker.SetAlertThreshold(0.8)  // Alert at 80%

// Check budget status
status := tracker.GetBudgetStatus()
fmt.Printf("Used: $%.2f / $%.2f (%.1f%%)\n",
    status.Used, status.Total, status.Percentage * 100)

if status.Alert {
    fmt.Println("⚠️  Budget alert!")
}

breakdown := tracker.GetCostByModel()

for model, cost := range breakdown {
    fmt.Printf("%s: $%.2f\n", model, cost)
}

// Output:
// gpt-4: $450.00
// gpt-3.5-turbo: $120.00
// claude-3-opus: $280.00

breakdown := tracker.GetCostByProvider()

for provider, cost := range breakdown {
    fmt.Printf("%s: $%.2f\n", provider, cost)
}

// Output:
// openai: $570.00
// anthropic: $280.00

// This month
thisMonth := tracker.GetCostForPeriod(
    time.Now().AddDate(0, 0, -30),
    time.Now(),
)

// Last 7 days
lastWeek := tracker.GetCostForPeriod(
    time.Now().AddDate(0, 0, -7),
    time.Now(),
)

// Today
today := tracker.GetCostForPeriod(
    time.Now().Truncate(24*time.Hour),
    time.Now(),
)

recommendations := tracker.GetOptimizationRecommendations()

for _, rec := range recommendations {
    fmt.Printf("💡 %s\n", rec.Title)
    fmt.Printf("   Potential savings: $%.2f/month\n", rec.PotentialSavings)
    fmt.Printf("   Action: %s\n", rec.Action)
}

// Output:
// 💡 Switch to GPT-3.5-Turbo for simple queries
//    Potential savings: $180.00/month
//    Action: Use gpt-3.5-turbo for non-complex tasks
//
// 💡 Enable caching
//    Potential savings: $120.00/month
//    Action: Cache similar requests to reduce API calls

insights := tracker.GetInsights()

fmt.Printf("Average cost per request: $%.4f\n", insights.AvgCostPerRequest)
fmt.Printf("Total requests: %d\n", insights.TotalRequests)
fmt.Printf("Most expensive model: %s ($%.2f)\n", 
    insights.MostExpensiveModel, insights.MostExpensiveCost)
fmt.Printf("Projected monthly cost: $%.2f\n", insights.ProjectedMonthly)

// Set up alerts
tracker.OnBudgetAlert(func(status sdk.BudgetStatus) {
    log.Printf("⚠️  Budget alert: %.1f%% used", status.Percentage * 100)
    notifyAdmin("Budget alert", status)
})

tracker.OnBudgetExceeded(func(status sdk.BudgetStatus) {
    log.Printf("🚨 Budget exceeded: $%.2f / $%.2f", 
        status.Used, status.Total)
    
    // Take action
    disableExpensiveModels()
    notifyAdmin("Budget exceeded", status)
})

// Monitor continuously
go tracker.MonitorBudget(ctx, 5*time.Minute)

generator := sdk.NewGenerateBuilder(ctx, llm, logger, metrics).
    WithPrompt("Long prompt...").
    WithCostLimit(0.10)  // Max $0.10 per request

result, err := generator.Execute()
if errors.Is(err, sdk.ErrCostLimitExceeded) {
    fmt.Println("Request would exceed cost limit")
}

type UserCostTracker struct {
    tracker *sdk.CostTracker
    limits  map[string]float64
}

func (u *UserCostTracker) CheckLimit(userID string, cost float64) error {
    limit := u.limits[userID]
    used := u.tracker.GetCostForUser(userID)
    
    if used + cost > limit {
        return fmt.Errorf("user %s exceeds limit", userID)
    }
    
    return nil
}

// Export to CSV
err := tracker.ExportToCSV("costs.csv", time.Now().AddDate(0, -1, 0), time.Now())

// CSV format:
// timestamp,model,provider,input_tokens,output_tokens,cost
// 2024-01-15 10:30:00,gpt-4,openai,100,200,0.006

data, err := tracker.ExportToJSON(startDate, endDate)

// Save to file
os.WriteFile("costs.json", data, 0644)

summary := tracker.GetDailySummary()

for date, cost := range summary {
    fmt.Printf("%s: $%.2f\n", date.Format("2006-01-02"), cost)
}

// Cost is automatically tracked
result, _ := sdk.NewGenerateBuilder(ctx, llm, logger, metrics).
    WithPrompt("Hello").
    WithCost(tracker).  // Enable cost tracking
    Execute()

// Cost automatically recorded
fmt.Printf("Request cost: $%.4f\n", result.Cost)

result, err := sdk.NewGenerateBuilder(ctx, llm, logger, metrics).
    WithPrompt("Expensive query...").
    WithCost(tracker).
    WithBudgetCheck(true).  // Check budget before executing
    Execute()

if errors.Is(err, sdk.ErrBudgetExceeded) {
    fmt.Println("Budget exceeded, request blocked")
}