# Create a virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install necessary SDKs
pip install anthropic openai python-dotenv loguru

# Initialize project
npm init -y

# Install dependencies
npm install anthropic openai dotenv winston
# For TypeScript users
npm install --save-dev typescript @types/node ts-node

import os
import logging
from typing import Dict, Any
from dotenv import load_dotenv
from anthropic import Anthropic, AnthropicError
from openai import OpenAI
from loguru import logger

# Load environment variables from .env file
load_dotenv()

class ResilientAIClient:
    def __init__(self):
        # Initialize primary client (Anthropic)
        self.primary_client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
        # Initialize fallback client (OpenAI)
        self.fallback_client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
        
        self.primary_model = "claude-3-5-sonnet-20240620" # Placeholder for Fable 5
        self.fallback_model = "gpt-4o"

    async def generate_response(self, prompt: str) -> Dict[str, Any]:
        """
        Attempts to use Anthropic first. If it fails due to security/ban errors,
        it automatically falls back to OpenAI.
        """
        logger.info(f"Attempting request with primary model: {self.primary_model}")

        try:
            # Attempt Primary (Anthropic)
            message = self.primary_client.messages.create(
                model=self.primary_model,
                max_tokens=1024,
                messages=[{"role": "user", "content": prompt}]
            )
            return {
                "content": message.content[0].text,
                "provider": "anthropic",
                "status": "success"
            }

        except (AnthropicError, Exception) as e:
            # This catches connectivity issues, 403 Forbidden, or API bans
            logger.error(f"Primary provider failed: {str(e)}")
            logger.warning("Initiating fallback sequence to OpenAI...")
            
            return self._fallback_request(prompt)

    def _fallback_request(self, prompt: str) -> Dict[str, Any]:
        """Internal method to handle the secondary provider logic."""
        try:
            response = self.fallback_client.chat.completions.create(
                model=self.fallback_model,
                messages=[{"role": "user", "content": prompt}]
            )
            return {
                "content": response.choices[0].message.content,
                "provider": "openai",
                "status": "fallback_active"
            }
        except Exception as e:
            logger.critical(f"All AI providers failed: {str(e)}")
            return {
                "content": "Error: All AI services are currently unavailable.",
                "provider": "none",
                "status": "failure"
            }

# --- Execution Block ---
if __name__ == "__main__":
    import asyncio

    async def main():
        ai_service = ResilientAIClient()
        user_prompt = "Explain the impact of AI regulation on software architecture."
        
        result = await ai_service.generate_response(user_prompt)
        
        print(f"\n--- AI Response ({result['provider'].upper()}) ---")
        print(f"Status: {result['status']}")
        print(f"Content: {result['content']}\n")

    asyncio.run(main())

import Anthropic from '@anthropic-ai/sdk';
import OpenAI from 'openai';
import dotenv from 'dotenv';
import winston from 'winston';

dotenv.config();

// Configure sophisticated logging
const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [new winston.transports.Console()],
});

interface AIResponse {
  content: string;
  provider: 'anthropic' | 'openai' | 'error';
  status: 'success' | 'fallback' | 'failed';
}

class ResilientAIService {
  private anthropic: Anthropic;
  private openai: OpenAI;

  constructor() {
    this.anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
    this.openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
  }

  /**
   * Orchestrates the model selection logic
   */
  public async chat(prompt: string): Promise<AIResponse> {
    try {
      logger.info('Attempting Anthropic Primary...');
      
      const msg = await this.anthropic.messages.create({
        model: 'claude-3-5-sonnet-20240620',
        max_tokens: 1024,
        messages: [{ role: 'user', content: prompt }],
      });

      return {
        content: msg.content[0].type === 'text' ? msg.content[0].text : '',
        provider: 'anthropic',
        status: 'success'
      };

    } catch (error: any) {
      logger.error(`Anthropic Error: ${error.message}`);
      return this.handleFallback(prompt);
    }
  }

  private async handleFallback(prompt: string): Promise<AIResponse> {
    logger.warn('Switching to OpenAI fallback...');
    
    try {
      const completion = await this.openai.chat.completions.create({
        model: 'gpt-4o',
        messages: [{ role: 'user', content: prompt }],
      });

      return {
        content: completion.choices[0].message.content || '',
        provider: 'openai',
        status: 'fallback'
      };
    } catch (error: any) {
      logger.error(`Fallback failed: ${error.message}`);
      return {
        content: 'Critical System Error: No providers available.',
        provider: 'error',
        status: 'failed'
      };
    }
  }
}

// --- Execution ---
const service = new ResilientAIService();
service.chat("What is the future of AI governance?")
  .then(res => console.log('Final Result:', res))
  .catch(err => console.error(err));

# Anthropic API Key (Primary)
ANTHROPIC_API_KEY=sk-ant-xxxx...

# OpenAI API Key (Fallback)
OPENAI_API_KEY=sk-proj-xxxx...

# Optional: Set to 'true' to force fallback for testing
FORCE_FALLBACK=false