feat(high): Add OpenAI API rate limiting with Token Bucket algorithm

Implemented comprehensive rate limiting:
- Token Bucket algorithm for RPM and TPM limits
- Separate buckets for requests/minute and tokens/minute
- Automatic token refilling at constant rate
- Graceful degradation with queuing when limits reached
- Concurrent request limiting with semaphore

Features:
- Per-model rate limits (gpt-4o: 30K TPM, gpt-4o-mini: 200K TPM)
- Automatic wait time calculation
- Statistics tracking (throttle rate, wait times, etc.)
- Thread-safe with asyncio locks
- Context manager API for easy usage

Integration:
- Integrated into Vision API (_call_openai_vision_api_with_retry)
- Automatic token estimation based on image and schema size
- Added to DI container with lazy initialization
- Global rate limiter registry for singleton pattern

Benefits:
- Prevents 429 rate limit errors from OpenAI
- Automatic queuing instead of failing requests
- Better resource utilization with concurrent limiting
- Detailed metrics for monitoring and optimization
- Configurable limits per model tier

Tests:
- 19 comprehensive unit tests for rate limiter
- Test token bucket algorithm, refilling, wait times
- Test concurrent request limiting
- Test per-model configuration
- All tests passing

Resolves: openai#5 (HIGH priority)
Impact: Eliminates rate limit errors and improves API reliability

Author: User

examples/erni-foto-agency/erni_foto_agency/di_container.py

@@ -26,6 +26,7 @@
 from .performance.cache_manager import ErniCacheManager
 from .performance.circuit_breaker import CircuitBreaker
 from .performance.cost_optimizer import CostBudget, CostOptimizer
+from .performance.rate_limiter import RateLimiter, get_rate_limiter
 from .utils.image_processor import ImageProcessor
 
 logger = structlog.get_logger(__name__)
@@ -62,11 +63,18 @@ def record_request(self, agent: str, duration: float, success: bool) -> None: ..
 
 class IImageProcessor(Protocol):
     """Interface for image processing"""
-    
+
     async def process_image(self, image_path: str) -> bytes: ...
     async def validate_image(self, image_path: str) -> bool: ...
 
 
+class IRateLimiter(Protocol):
+    """Interface for rate limiting"""
+
+    async def acquire(self, estimated_tokens: int) -> Any: ...
+    def get_stats(self) -> dict[str, Any]: ...
+
+
 # ============================================================================
 # Dependency Injection Container
 # ============================================================================
@@ -113,6 +121,8 @@ def __init__(self, config: ErniConfig | None = None):
         self._image_processor: ImageProcessor | None = None
         self._batch_processor: BatchProcessor | None = None
         self._cost_optimizer: CostOptimizer | None = None
+        self._rate_limiter_gpt4o: RateLimiter | None = None
+        self._rate_limiter_gpt4o_mini: RateLimiter | None = None
 
         # Agents (lazy-initialized)
         self._schema_extractor: SharePointSchemaExtractorAgent | None = None
@@ -238,6 +248,32 @@ def cost_optimizer(self, value: CostOptimizer) -> None:
         """Set cost optimizer (for testing)"""
         self._cost_optimizer = value
 
+    @property
+    def rate_limiter_gpt4o(self) -> RateLimiter:
+        """Get rate limiter for GPT-4o (singleton)"""
+        if self._rate_limiter_gpt4o is None:
+            self._rate_limiter_gpt4o = get_rate_limiter("gpt-4o")
+            logger.debug("Rate limiter for gpt-4o created")
+        return self._rate_limiter_gpt4o
+
+    @rate_limiter_gpt4o.setter
+    def rate_limiter_gpt4o(self, value: RateLimiter) -> None:
+        """Set rate limiter for GPT-4o (for testing)"""
+        self._rate_limiter_gpt4o = value
+
+    @property
+    def rate_limiter_gpt4o_mini(self) -> RateLimiter:
+        """Get rate limiter for GPT-4o-mini (singleton)"""
+        if self._rate_limiter_gpt4o_mini is None:
+            self._rate_limiter_gpt4o_mini = get_rate_limiter("gpt-4o-mini")
+            logger.debug("Rate limiter for gpt-4o-mini created")
+        return self._rate_limiter_gpt4o_mini
+
+    @rate_limiter_gpt4o_mini.setter
+    def rate_limiter_gpt4o_mini(self, value: RateLimiter) -> None:
+        """Set rate limiter for GPT-4o-mini (for testing)"""
+        self._rate_limiter_gpt4o_mini = value
+
     # ========================================================================
     # AI Agents
     # ========================================================================
@@ -381,6 +417,8 @@ def reset(self) -> None:
         self._image_processor = None
         self._batch_processor = None
         self._cost_optimizer = None
+        self._rate_limiter_gpt4o = None
+        self._rate_limiter_gpt4o_mini = None
         self._schema_extractor = None
         self._vision_analyzer = None
         self._sharepoint_uploader = None

examples/erni-foto-agency/erni_foto_agency/erni_agents/structured_vision_analyzer.py

@@ -38,6 +38,7 @@
 from ..performance.cache_manager import ErniCacheManager
 from ..performance.circuit_breaker import call_openai_with_circuit_breaker
 from ..performance.cost_optimizer import CostBudget, CostOptimizer, ModelType
+from ..performance.rate_limiter import get_rate_limiter
 from ..utils.image_processor import ImageProcessor
 from ..utils.pii_detector import PIIDetector
 
@@ -563,14 +564,19 @@ async def _call_openai_vision_api_with_retry(
     api_key: str,
 ) -> Any:
     """
-    Call OpenAI Vision API with retry logic and exponential backoff
+    Call OpenAI Vision API with retry logic, rate limiting, and exponential backoff
 
     Retry strategy:
     - Max 3 attempts
     - Exponential backoff: 2s, 4s, 8s (capped at 30s)
     - Retry on: timeout, connection errors, rate limits, 5xx errors
     - No retry on: 4xx errors (except 429 rate limit)
 
+    Rate limiting:
+    - Token bucket algorithm for RPM and TPM limits
+    - Automatic queuing when limits reached
+    - Per-model rate limits (gpt-4o vs gpt-4o-mini)
+
     Args:
         base64_image: Base64-encoded image
         json_schema: JSON schema for structured output
@@ -585,14 +591,24 @@ async def _call_openai_vision_api_with_retry(
         RetryableAPIError: For 5xx and 429 errors
         openai.APIStatusError: For non-retryable 4xx errors
     """
+    # Get rate limiter for this model
+    rate_limiter = get_rate_limiter(model)
+
+    # Estimate tokens for rate limiting
+    # Vision API typically uses ~1000-2000 tokens per image
+    # Add tokens for prompt and schema
+    estimated_tokens = 1500 + len(json_schema) // 4  # Rough estimate
+
     try:
-        # Create specialized prompt based on fields
-        system_prompt = _create_system_prompt(fields_to_analyze)
-        user_prompt = _create_user_prompt(fields_to_analyze)
+        # Acquire rate limit before making request
+        async with rate_limiter.acquire(estimated_tokens=estimated_tokens):
+            # Create specialized prompt based on fields
+            system_prompt = _create_system_prompt(fields_to_analyze)
+            user_prompt = _create_user_prompt(fields_to_analyze)
 
-        client = openai.AsyncOpenAI(api_key=api_key)
+            client = openai.AsyncOpenAI(api_key=api_key)
 
-        response = await client.chat.completions.create(
+            response = await client.chat.completions.create(
             model=model,
             messages=[
                 {"role": "system", "content": system_prompt},