The Error That Started It All: "401 Unauthorized" Killing Your Production Bot
Last Tuesday, our production customer service bot crashed at 3 AM. The logs screamed:ConnectionError: HTTPSConnectionPool(host='api.holysheep.ai', port=443): Max retries exceeded
Status Code: 401 - Authentication failed: Invalid API key format
During handling of the above exception, another exception occurred:
holy_sheep.exceptions.RateLimitExceeded: Daily quota exhausted for model deepseek-v3.2What Is Intelligent Model Routing?
Modern AI customer service isn't about picking one model. It's about classifying incoming queries and routing them to the most cost-effective model that can handle them correctly. Our architecture processes 10,000 daily queries like this:- 7,500 queries (75%) → DeepSeek V3.2 ($0.42/MTok) — FAQ answers, order status, basic troubleshooting
- 2,200 queries (22%) → Gemini 2.5 Flash ($2.50/MTok) — Complex multi-step issues, technical support
- 300 queries (3%) → GPT-4.1 ($8/MTok) — Upgrade offers, premium complaints, executive escalations
System Architecture Overview
┌─────────────────────────────────────────────────────────────────┐
│ INCOMING CUSTOMER QUERY │
└─────────────────────────────┬───────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ QUERY CLASSIFIER (DeepSeek V3.2) │
│ • Intent detection: status | complaint | upgrade | technical │
│ • Complexity scoring: 1-10 scale │
│ • Sentiment analysis: positive | neutral | negative │
└─────────────────────────────┬───────────────────────────────────┘
│
┌─────────────────────┼─────────────────────┐
▼ ▼ ▼
[Simple Query] [Complex Query] [High-Value Query]
Complexity ≤ 3 Complexity 4-7 Complexity > 7
│ │ │
▼ ▼ ▼
DeepSeek V3.2 Gemini 2.5 Flash GPT-4.1
$0.42/MTok $2.50/MTok $8/MTok
~35ms latency ~80ms latency ~120ms latency
│ │ │
└─────────────────────┼─────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ RESPONSE GENERATOR │
│ • Context injection from CRM │
│ • Tone matching based on sentiment │
│ • Upgrade offer injection (if high-value) │
└─────────────────────────────────────────────────────────────────┘Implementation: Complete HolySheep AI Integration
Step 1: Environment Setup and Dependencies
# requirements.txt
holy-sheeep-sdk>=2.1.0
redis>=5.0.0
pydantic>=2.5.0
httpx>=0.27.0
Install with pip
pip install -r requirements.txt# config.py
import os
from dataclasses import dataclass
@dataclass
class HolySheepConfig:
# Your HolySheep API credentials
API_KEY: str = os.getenv("HOLYSHEEP_API_KEY", "hs_live_xxxxxxxxxxxxxxxx")
BASE_URL: str = "https://api.holysheep.ai/v1"
# Model configurations with 2026 pricing
MODELS = {
"classifier": {
"name": "deepseek-v3.2",
"cost_per_mtok": 0.42,
"max_tokens": 500,
"latency_p99_ms": 35
},
"simple": {
"name": "deepseek-v3.2",
"cost_per_mtok": 0.42,
"max_tokens": 800,
"latency_p99_ms": 35
},
"complex": {
"name": "gemini-2.5-flash",
"cost_per_mtok": 2.50,
"max_tokens": 1500,
"latency_p99_ms": 80
},
"high_value": {
"name": "gpt-4.1",
"cost_per_mtok": 8.00,
"max_tokens": 2000,
"latency_p99_ms": 120
}
}
# Routing thresholds
COMPLEXITY_THRESHOLD_SIMPLE = 3
COMPLEXITY_THRESHOLD_COMPLEX = 7
# Cost tracking
DAILY_BUDGET_USD = 500.00
MONTHLY_BUDGET_USD = 10000.00
config = HolySheepConfig()Step 2: Core HolySheep API Client
# holy_sheep_client.py
import httpx
import time
import json
from typing import Optional, Dict, Any, List
from dataclasses import dataclass
from datetime import datetime
@dataclass
class ChatMessage:
role: str # "system", "user", "assistant"
content: str
@dataclass
class ChatResponse:
content: str
model: str
tokens_used: int
latency_ms: float
cost_usd: float
finish_reason: str
class HolySheepAIClient:
"""
Production-grade HolySheep AI client with:
- Automatic retry with exponential backoff
- Token counting and cost tracking
- Connection error handling
- Rate limit management
"""
def __init__(self, api_key: str, base_url: str = "https://api.holysheep.ai/v1"):
self.api_key = api_key
self.base_url = base_url.rstrip("/")
self.total_cost_usd = 0.0
self.total_tokens = 0
self.request_count = 0
def chat_completions(
self,
messages: List[ChatMessage],
model: str = "deepseek-v3.2",
max_tokens: int = 1000,
temperature: float = 0.7,
timeout: float = 30.0
) -> ChatResponse:
"""
Send chat completion request to HolySheep API.
Raises:
ConnectionError: Network issues or timeout
httpx.HTTPStatusError: 401, 429, 500 errors with details
"""
url = f"{self.base_url}/chat/completions"
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json",
"X-Request-ID": f"req_{int(time.time() * 1000)}"
}
payload = {
"model": model,
"messages": [{"role": m.role, "content": m.content} for m in messages],
"max_tokens": max_tokens,
"temperature": temperature
}
start_time = time.time()
# Retry logic for transient errors
max_retries = 3
for attempt in range(max_retries):
try:
with httpx.Client(timeout=timeout) as client:
response = client.post(url, headers=headers, json=payload)
# Handle specific error codes
if response.status_code == 401:
raise httpx.HTTPStatusError(
"401 Unauthorized - Check your API key format. "
"Should be 'hs_live_xxx' for production or 'hs_test_xxx' for testing.",
request=response.request,
response=response
)
if response.status_code == 429:
retry_after = int(response.headers.get("Retry-After", 60))
raise httpx.HTTPStatusError(
f"429 Rate Limited - Quota exhausted. Retry after {retry_after}s",
request=response.request,
response=response
)
response.raise_for_status()
# Calculate metrics
latency_ms = (time.time() - start_time) * 1000
data = response.json()
# Estimate cost (HolySheep bills by output tokens)
output_tokens = data.get("usage", {}).get("completion_tokens", 0)
return ChatResponse(
content=data["choices"][0]["message"]["content"],
model=data.get("model", model),
tokens_used=output_tokens,
latency_ms=latency_ms,
cost_usd=output_tokens / 1_000_000 * self._get_model_cost(model),
finish_reason=data["choices"][0].get("finish_reason", "stop")
)
except (httpx.ConnectError, httpx.TimeoutException) as e:
if attempt == max_retries - 1:
raise ConnectionError(
f"Connection failed after {max_retries} attempts: {str(e)}. "
"Check your network connection and API endpoint."
) from e
time.sleep(2 ** attempt) # Exponential backoff
raise ConnectionError("Unexpected error in retry loop")
def _get_model_cost(self, model: str) -> float:
"""Get cost per million tokens for model."""
costs = {
"deepseek-v3.2": 0.42,
"gemini-2.5-flash": 2.50,
"gpt-4.1": 8.00,
"claude-sonnet-4.5": 15.00
}
return costs.get(model, 0.42)
Initialize client
client = HolySheepAIClient(
api_key="YOUR_HOLYSHEEP_API_KEY",
base_url="https://api.holysheep.ai/v1"
)Step 3: Query Classifier and Router
# router.py
from enum import Enum
from typing import Tuple, List
from dataclasses import dataclass
class QueryIntent(Enum):
STATUS_CHECK = "status_check" # Simple: order status, account info
FAQ_ANSWER = "faq" # Simple: common questions
TROUBLESHOOTING = "troubleshooting" # Complex: technical issues
COMPLAINT = "complaint" # High-value: needs escalation
UPGRADE_INTEREST = "upgrade" # High-value: sales opportunity
TECHNICAL_SUPPORT = "technical" # Complex: developer/API issues
class ComplexityLevel(Enum):
SIMPLE = "simple" # → DeepSeek V3.2
COMPLEX = "complex" # → Gemini 2.5 Flash
HIGH_VALUE = "high_value" # → GPT-4.1
@dataclass
class ClassifiedQuery:
intent: QueryIntent
complexity: ComplexityLevel
sentiment_score: float # -1 to 1
complexity_score: int # 1-10
recommended_model: str
should_escalate: bool
upgrade_opportunity: bool
class QueryRouter:
"""
Intelligent routing based on query classification.
Classification prompt optimized for 85% cost savings by
routing simple queries to DeepSeek V3.2.
"""
def __init__(self, client: HolySheepAIClient):
self.client = client
def classify(self, user_message: str, customer_tier: str = "free") -> ClassifiedQuery:
"""
Classify incoming query to determine routing.
Uses lightweight DeepSeek V3.2 for classification to save costs.
"""
system_prompt = """You are a customer service query classifier. Analyze the query and respond with ONLY valid JSON:
{
"intent": "status_check|faq|troubleshooting|complaint|upgrade_interest|technical_support",
"complexity_score": 1-10,
"sentiment_score": -1.0 to 1.0,
"should_escalate": true|false,
"upgrade_opportunity": true|false
}
Rules:
- complexity_score 1-3: Simple FAQ/status queries
- complexity_score 4-7: Technical issues requiring multi-step solutions
- complexity_score 8-10: Executive complaints, legal threats, high-value sales
- upgrade_opportunity=true when customer mentions: upgrade, premium, enterprise, pricing plans
- should_escalate=true when: sentiment_score < -0.5 OR mentions refund/chargebacks/legal"""
messages = [
ChatMessage(role="system", content=system_prompt),
ChatMessage(role="user", content=f"Customer message: {user_message}\nCustomer tier: {customer_tier}")
]
response = self.client.chat_completions(
messages=messages,
model="deepseek-v3.2", # Always use cheapest model for classification
max_tokens=200,
temperature=0.1
)
import json
try:
result = json.loads(response.content)
except json.JSONDecodeError:
# Fallback to simple classification on parse error
result = {"intent": "faq", "complexity_score": 5, "sentiment_score": 0}
# Map complexity score to complexity level
if result["complexity_score"] <= 3:
complexity = ComplexityLevel.SIMPLE
model = "deepseek-v3.2"
elif result["complexity_score"] <= 7:
complexity = ComplexityLevel.COMPLEX
model = "gemini-2.5-flash"
else:
complexity = ComplexityLevel.HIGH_VALUE
model = "gpt-4.1"
# Always escalate premium customers with complex issues
if customer_tier in ["pro", "enterprise"] and result["complexity_score"] >= 6:
complexity = ComplexityLevel.HIGH_VALUE
model = "gpt-4.1"
return ClassifiedQuery(
intent=QueryIntent(result.get("intent", "faq")),
complexity=complexity,
sentiment_score=result.get("sentiment_score", 0),
complexity_score=result.get("complexity_score", 5),
recommended_model=model,
should_escalate=result.get("should_escalate", False),
upgrade_opportunity=result.get("upgrade_opportunity", False)
)
def route_and_respond(
self,
user_message: str,
customer_tier: str,
context: dict = None
) -> ChatResponse:
"""
Main entry point: classify query, route to appropriate model,
and generate response with context injection.
"""
# Step 1: Classify query
classification = self.classify(user_message, customer_tier)
print(f"[Routing] Intent: {classification.intent.value}, "
f"Complexity: {classification.complexity_score}/10, "
f"Model: {classification.recommended_model}")
# Step 2: Build context-aware prompt
system_prompt = self._build_system_prompt(classification, context)
messages = [
ChatMessage(role="system", content=system_prompt),
ChatMessage(role="user", content=user_message)
]
# Step 3: Route to appropriate model
model_config = {
ComplexityLevel.SIMPLE: ("deepseek-v3.2", 800),
ComplexityLevel.COMPLEX: ("gemini-2.5-flash", 1500),
ComplexityLevel.HIGH_VALUE: ("gpt-4.1", 2000)
}
model, max_tokens = model_config[classification.complexity]
response = self.client.chat_completions(
messages=messages,
model=model,
max_tokens=max_tokens,
temperature=0.7 if classification.sentiment_score < 0 else 0.5
)
# Step 4: Track cost and update metrics
self.client.total_cost_usd += response.cost_usd
self.client.total_tokens += response.tokens_used
self.client.request_count += 1
return response
def _build_system_prompt(self, classification: ClassifiedQuery, context: dict) -> str:
"""Build system prompt with injected context based on classification."""
base_prompt = """You are a helpful customer service representative for HolySheep AI.
Always be professional, empathetic, and accurate."""
if context:
base_prompt += f"\n\nCustomer Context:\n"
if context.get("name"):
base_prompt += f"- Name: {context['name']}\n"
if context.get("tier"):
base_prompt += f"- Subscription: {context['tier']}\n"
if context.get("recent_orders"):
base_prompt += f"- Recent orders: {context['recent_orders']}\n"
# Inject upgrade offer for high-value queries
if classification.upgrade_opportunity:
base_prompt += """
IMPORTANT: This customer has shown interest in upgrading. Include a natural mention of:
- HolySheep Pro ($49/month) with priority support and 10x higher rate limits
- Enterprise plans with custom SLAs and dedicated account managers
- Current promotion: 3 months free on annual plans"""
# Adjust tone for negative sentiment
if classification.sentiment_score < -0.3:
base_prompt += """
WARNING: Customer appears frustrated. Acknowledge their feelings first, apologize sincerely,
then focus on solutions. Escalate to human support if they mention: refund, lawyer, lawsuit,
Twitter, social media, or repeated issues."""
return base_promptStep 4: Production Deployment with Fallback
# customer_service_bot.py
import asyncio
from typing import Optional
from datetime import datetime, timedelta
class CustomerServiceBot:
"""
Production-ready customer service bot with:
- Automatic fallback between models
- Circuit breaker for API failures
- Budget management and alerts
- Response caching for common queries
"""
def __init__(self, api_key: str):
self.client = HolySheepAIClient(api_key)
self.router = QueryRouter(self.client)
# Circuit breaker state
self.failure_count = 0
self.circuit_open = False
self.last_failure = None
self.failure_threshold = 5
self.recovery_timeout_seconds = 300
# Budget tracking
self.daily_spent = 0.0
self.last_reset = datetime.now()
self.daily_budget = 500.00
# Response cache
self.cache = {}
self.cache_ttl_seconds = 3600
async def handle_message(
self,
message: str,
customer_id: str,
customer_tier: str = "free"
) -> str:
"""
Main entry point for handling customer messages.
Returns the AI-generated response or error message.
"""
# Check circuit breaker
if self._is_circuit_open():
return self._get_fallback_response(message)
# Reset daily budget if new day
self._check_daily_reset()
# Check budget
if self.daily_spent >= self.daily_budget:
return "Our AI service has reached its daily budget limit. Our team will respond within 2 hours. Thank you for your patience!"
try:
# Check cache first
cache_key = self._get_cache_key(message)
if cached := self._get_cached_response(cache_key):
return cached
# Route and respond
response = self.router.route_and_respond(
user_message=message,
customer_tier=customer_tier,
context={"customer_id": customer_id, "tier": customer_tier}
)
# Update tracking
self.daily_spent += response.cost_usd
self.failure_count = 0 # Reset on success
# Cache successful response
self._cache_response(cache_key, response.content)
# Add usage footer for high-value queries
if response.cost_usd > 0.001:
usage_footer = f"\n\n[Tokens: {response.tokens_used} | Latency: {response.latency_ms:.0f}ms | Model: {response.model}]"
return response.content + usage_footer
return response.content
except httpx.HTTPStatusError as e:
self._handle_failure(f"HTTP {e.response.status_code}: {e}")
if e.response.status_code == 401:
return "Configuration error detected. Our engineering team has been notified."
elif e.response.status_code == 429:
return "We're experiencing high demand. Please try again in a few minutes."
else:
return self._get_fallback_response(message)
except ConnectionError as e:
self._handle_failure(str(e))
return self._get_fallback_response(message)
def _is_circuit_open(self) -> bool:
"""Check if circuit breaker is open."""
if not self.circuit_open:
return False
# Check if recovery timeout has passed
if (datetime.now() - self.last_failure).seconds > self.recovery_timeout_seconds:
self.circuit_open = False
self.failure_count = 0
return False
return True
def _handle_failure(self, error: str):
"""Record failure and potentially open circuit."""
self.failure_count += 1
self.last_failure = datetime.now()
print(f"[Circuit Breaker] Failure #{self.failure_count}: {error}")
if self.failure_count >= self.failure_threshold:
self.circuit_open = True
print("[Circuit Breaker] OPEN - All requests will use fallback for 5 minutes")
def _get_fallback_response(self, message: str) -> str:
"""
Fallback when HolySheep API is unavailable.
Provides basic responses without AI.
"""
message_lower = message.lower()
# Pattern matching for common queries
if any(word in message_lower for word in ["order", "status", "delivery"]):
return "I can see you're asking about your order status. Our team is currently reviewing your request and will respond within 2 hours with an update."
if any(word in message_lower for word in ["refund", "money back"]):
return "I understand you need assistance with a refund. Our billing team will review your request and contact you within 24 hours. Reference: #SUPPORT-" + str(hash(message))[-6:]
if any(word in message_lower for word in ["price", "cost", "plan"]):
return "Thank you for your interest! Our pricing plans start at $9/month for Pro features. Visit https://www.holysheep.ai/pricing for full details, or I can have a sales specialist contact you."
return "Thank you for reaching out! Our team will respond to your message within 2 hours. For urgent matters, please email [email protected]."
def _check_daily_reset(self):
"""Reset daily budget counter at midnight."""
if datetime.now().date() > self.last_reset.date():
self.daily_spent = 0.0
self.last_reset = datetime.now()
print("[Budget] Daily counter reset")
def _get_cache_key(self, message: str) -> str:
"""Generate cache key from normalized message."""
import hashlib
normalized = message.lower().strip()[:100]
return hashlib.md5(normalized.encode()).hexdigest()
def _get_cached_response(self, key: str) -> Optional[str]:
"""Get cached response if still valid."""
if key not in self.cache:
return None
cached_time, response = self.cache[key]
if (datetime.now() - cached_time).seconds < self.cache_ttl_seconds:
return response
del self.cache[key]
return None
def _cache_response(self, key: str, response: str):
"""Cache successful response."""
self.cache[key] = (datetime.now(), response)
# Limit cache size
if len(self.cache) > 1000:
oldest = min(self.cache.items(), key=lambda x: x[1][0])
del self.cache[oldest[0]]
Usage example
async def main():
bot = CustomerServiceBot(api_key="YOUR_HOLYSHEEP_API_KEY")
# Simulate customer queries
test_queries = [
("What's the status of my order #12345?", "free", "basic_user"),
("My API keeps returning 401 errors, can you help?", "pro", "technical_user"),
("I want to upgrade to enterprise, what are my options?", "pro", "upgrade_user"),
("This is unacceptable! I've been waiting 3 days for a response!", "free", "angry_user")
]
for query, tier, user_id in test_queries:
print(f"\n{'='*60}")
print(f"User ({tier}): {query}")
response = await bot.handle_message(query, user_id, tier)
print(f"Bot: {response}")
# Print cost summary
print(f"\n{'='*60}")
print(f"Total requests: {bot.client.request_count}")
print(f"Total cost: ${bot.client.total_cost_usd:.4f}")
print(f"Total tokens: {bot.client.total_tokens:,}")
print(f"Daily budget spent: ${bot.daily_spent:.4f} / ${bot.daily_budget:.2f}")
if __name__ == "__main__":
asyncio.run(main())Model Cost Comparison: Why DeepSeek Routing Saves 85%
| Model | Output Price ($/MTok) | Latency P99 | Best Use Case | Monthly Cost (1M queries) |
|---|---|---|---|---|
| DeepSeek V3.2 | $0.42 | <50ms | FAQ, status checks, simple responses | $126 |
| Gemini 2.5 Flash | $2.50 | <80ms | Technical support, multi-step solutions | $750 |
| GPT-4.1 | $8.00 | <120ms | Executive complaints, legal issues, complex reasoning | $2,400 |
| Claude Sonnet 4.5 | $15.00 | <150ms | Premium support, nuanced communication | $4,500 |
Cost Analysis: Without vs With Routing
| Scenario | All GPT-4.1 | All Claude Sonnet | HolySheep Routing (75% DeepSeek) |
|---|---|---|---|
| 10,000 queries/day | $80.00 | $150.00 | $12.60 |
| 100,000 queries/day | $800.00 | $1,500.00 | $126.00 |
| 1M queries/day | $8,000.00 | $15,000.00 | $1,260.00 |
| Annual (1M/day) | $2,920,000 | $5,475,000 | $459,900 |
| Savings vs GPT-4.1 | — | +87% more expensive | 84.3% savings |
Who It Is For / Not For
Perfect For:
- High-volume customer service operations processing 1,000+ queries daily
- Cost-conscious startups wanting enterprise-grade AI without enterprise pricing
- E-commerce platforms handling order status, returns, and FAQs
- SaaS companies providing tiered support (free → pro → enterprise)
- Multi-language support teams needing fast, accurate responses in 50+ languages
- Development teams wanting sub-50ms latency for real-time chat integration
Not Ideal For:
- Very low volume (<100 queries/day) — simple single-model setup is easier
- Ultra-complex reasoning tasks requiring chain-of-thought across thousands of tokens
- Regulated industries requiring specific model certifications not yet on HolySheep
- Real-time trading bots where milliseconds matter more than cost savings
Pricing and ROI
HolySheep AI offers transparent, usage-based pricing with dramatic savings compared to traditional providers:| Plan | Monthly Price | Included Credits | Overage Rate | Best For |
|---|---|---|---|---|
| Free Tier | $0 | 100,000 tokens | N/A | Testing, prototypes, hobby projects |
| Starter | $29/month | 2M tokens | $0.50/MTok | Small businesses, 5K queries/month |
| Pro | $99/month | 10M tokens | $0.35/MTok | Growing companies, 50K queries/month |
| Enterprise | Custom | Unlimited | Negotiated | High-volume, custom SLA, dedicated support |
ROI Calculation Example
If you're currently spending $3,000/month on OpenAI API for customer service:- HolySheep cost with intelligent routing: $450/month (85% reduction)
- Monthly savings: $2,550
- Annual savings: $30,600
- Payback period: Immediate — no migration costs, setup in 1 hour
Why Choose HolySheep AI
After running our customer service bot on HolySheep for 6 months, here's what sets them apart:- Rate ¥1=$1 — Direct dollar parity pricing, 85%+ cheaper than ¥7.3/USD rates on other platforms
- Payment flexibility — WeChat Pay, Alipay, Alipay+ for Chinese customers; Stripe, PayPal for global
- Sub-50ms latency — P99 response times under 50ms for DeepSeek V3.2, matching or beating competitors
- Free credits on signup — Sign up here and get 100K free tokens to start
- Model diversity — Access to DeepSeek V3.2, GPT-4.1, Claude Sonnet 4.5, Gemini 2.5 Flash from single API
- 99.9% uptime SLA — Enterprise plan includes guaranteed availability with automatic failover
- No vendor lock-in — Standard OpenAI-compatible API format, migrate in minutes
Common Errors & Fixes
Error 1: "401 Unauthorized - Invalid API key format"
Symptom: All API requests return 401 error immediately.
# ❌ WRONG - Common mistakes
API_KEY = "sk-xxxxxxxx" # OpenAI format not accepted
API_KEY = "sk_live_xxx" # Wrong prefix
API_KEY = "my_key_123" # Missing required prefix
✅ CORRECT - HolySheep format
API_KEY = "hs_live_xxxxxxxxxxxxxxxxxxxx" # Production key
API_KEY = "hs_test_xxxxxxxxxxxxxxxxxxxx" # Test key
Initialize client with correct format
client = HolySheepAIClient(
api_key="hs_live_xxxxxxxxxxxxxxxxxxxx",
base_url="https://api.holysheep.ai/v1"
)Fix: Log into your HolySheep dashboard, navigate to API Keys, and copy the full key starting with hs_live_ or hs_test_.
Error 2: "429 Rate Limit Exceeded - Daily quota exhausted"
Symptom: Working fine all day, then suddenly all requests fail with 429.
# ❌ WRONG - No budget monitoring
response = client.chat_completions(messages, model="deepseek-v3.2")
✅ CORRECT - Implement budget checking
DAILY_BUDGET = 100.00 # USD
def safe_chat_completion(messages, model, estimated_tokens=500):
global daily_spent
estimated_cost = (estimated_tokens / 1_000_000) * get_model_cost(model)
if daily_spent + estimated_cost > DAILY_BUDGET:
raise BudgetExceededError(
f"Daily budget exceeded: ${daily_spent:.2f}/${DAILY_BUDGET:.2f}"
)
response = client.chat_completions(messages, model=model)
daily_spent