Debugging & Error Handling

import time
import random
from typing import Optional, Dict, Any

class LookCMCPClient:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.endpoint = "https://api.lookc.io/mcp"
        
    async def call_tool_with_retry(
        self, 
        tool_name: str, 
        arguments: Dict[str, Any],
        max_retries: int = 3
    ) -> Optional[Dict[str, Any]]:
        """Call LookC tool with comprehensive error handling."""
        
        for attempt in range(max_retries):
            try:
                result = await self._make_request(tool_name, arguments)
                return result
                
            except requests.exceptions.Timeout:
                if attempt < max_retries - 1:
                    wait_time = (2 ** attempt) + random.uniform(0, 1)
                    print(f"⏱️ Timeout on attempt {attempt + 1}, retrying in {wait_time:.1f}s")
                    await asyncio.sleep(wait_time)
                else:
                    print("❌ All retry attempts failed due to timeout")
                    raise
                    
            except requests.exceptions.HTTPError as e:
                if e.response.status_code == 429:  # Rate limited
                    retry_after = int(e.response.headers.get('Retry-After', 60))
                    print(f"🚦 Rate limited, waiting {retry_after}s")
                    await asyncio.sleep(retry_after)
                elif e.response.status_code in [500, 502, 503, 504]:  # Server errors
                    if attempt < max_retries - 1:
                        wait_time = (2 ** attempt) + random.uniform(0, 1)
                        print(f"🔧 Server error {e.response.status_code}, retrying in {wait_time:.1f}s")
                        await asyncio.sleep(wait_time)
                    else:
                        print(f"❌ Server error {e.response.status_code} persists after retries")
                        raise
                else:
                    print(f"❌ HTTP error {e.response.status_code}: {e.response.text}")
                    raise
                    
            except Exception as e:
                print(f"❌ Unexpected error: {e}")
                if attempt == max_retries - 1:
                    raise
                await asyncio.sleep(1)
        
        return None

import os
from dataclasses import dataclass

@dataclass
class LookCConfig:
    api_key: str
    endpoint: str = "https://api.lookc.io/mcp"
    timeout: int = 30
    max_retries: int = 3
    debug_mode: bool = False
    
    @classmethod
    def from_environment(cls):
        return cls(
            api_key=os.getenv('LOOKC_API_KEY'),
            endpoint=os.getenv('LOOKC_ENDPOINT', 'https://api.lookc.io/mcp'),
            timeout=int(os.getenv('LOOKC_TIMEOUT', '30')),
            max_retries=int(os.getenv('LOOKC_MAX_RETRIES', '3')),
            debug_mode=os.getenv('LOOKC_DEBUG', 'false').lower() == 'true'
        )

# Development configuration
dev_config = LookCConfig(
    api_key="dev_api_key",
    timeout=60,  # Longer timeout for debugging
    max_retries=1,  # Fail fast in development
    debug_mode=True
)

# Production configuration
prod_config = LookCConfig(
    api_key="prod_api_key",
    timeout=30,
    max_retries=3,
    debug_mode=False
)