Error Handling & Recovery Patterns

from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
 
@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=2, max=30),
    retry=retry_if_exception_type(TransientError)
)
async def call_openai(client, messages, max_tokens=500):
    try:
        response = await client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            max_tokens=max_tokens,
            timeout=30
        )
        return response.choices[0].message.content
    except httpx.HTTPStatusError as e:
        if e.response.status_code == 429:
            raise TransientError(f"Rate limited: {e}")
        if e.response.status_code >= 500:
            raise TransientError(f"Server error: {e}")
        raise  # Non-retryable

async function callOpenAI(client, messages, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const response = await client.chat.completions.create({
        model: 'gpt-4o',
        messages,
        max_tokens: 500,
      });
      return response.choices[0].message.content;
    } catch (error) {
      const status = error?.status;
      if ((status === 429 || status >= 500) && attempt < maxRetries) {
        const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
        await new Promise(r => setTimeout(r, delay));
        continue;
      }
      throw error;
    }
  }
}

import time
 
class CircuitBreaker:
    def __init__(self, failure_threshold=5, recovery_timeout=60):
        self.failure_count = 0
        self.failure_threshold = failure_threshold
        self.recovery_timeout = recovery_timeout
        self.last_failure_time = 0
        self.state = "closed"  # closed | open | half-open
 
    def call(self, func, *args, **kwargs):
        if self.state == "open":
            if time.time() - self.last_failure_time > self.recovery_timeout:
                self.state = "half-open"
            else:
                raise Exception("Circuit breaker OPEN")
        try:
            result = func(*args, **kwargs)
            if self.state == "half-open":
                self.state = "closed"
                self.failure_count = 0
            return result
        except Exception:
            self.failure_count += 1
            self.last_failure_time = time.time()
            if self.failure_count >= self.failure_threshold:
                self.state = "open"
            raise

@mcp.tool()
async def search_knowledge(query: str, max_results: int = 5) -> str:
    """Search FROOT knowledge modules."""
    if not query or len(query) > 500:
        return '{"error": "Query must be 1-500 characters"}'
 
    try:
        results = perform_search(query, max_results)
        return json.dumps({"results": results})
    except FileNotFoundError:
        return json.dumps({"error": "Knowledge base not found"})
    except Exception as e:
        logger.error(f"Search failed: {e}", exc_info=True)
        return json.dumps({"error": "Search temporarily unavailable"})

function withTimeout(promise, ms, label = 'Operation') {
  let timer;
  const timeout = new Promise((_, reject) => {
    timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
  });
  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
}
 
const result = await withTimeout(callOpenAI(client, messages), 30000, 'Azure OpenAI');