Deploy backend from GitHub Actions

🚀 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

src/agents/personalization_agent.py

@@ -40,20 +40,7 @@ class PersonalizationAgent:
         except Exception as e:
             print(f"[WARNING] Failed to disable tracing: {e}")
 
-        # Initialize primary Gemini client
-        try:
-            self.gemini_client = AsyncOpenAI(
-                api_key=os.getenv("GEMINI_API_KEY"),
-                base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
-                timeout=120.0,
-                max_retries=3
-            )
-            print("[DEBUG] Gemini client initialized successfully")
-        except Exception as e:
-            print(f"[ERROR] Failed to initialize Gemini client: {e}")
-            self.gemini_client = None
-
-        # Initialize fallback OpenRouter client
+        # Initialize primary OpenRouter client
         self.openrouter_client = None
         if os.getenv("OPENROUTER_API_KEY"):
             try:
@@ -72,14 +59,15 @@ class PersonalizationAgent:
                 print(f"[ERROR] Failed to initialize OpenRouter client: {e}")
                 self.openrouter_client = None
 
-        # Configure primary model (Gemini)
+        # Configure primary model (OpenRouter)
         self.primary_model = None
-        if self.gemini_client:
+        if self.openrouter_client:
             try:
-                model_name = os.getenv("GEMINI_MODEL", "gemini-2.0-flash")
+                # Use a working free model with fewer restrictions
+                model_name = os.getenv("OPENROUTER_MODEL", "meta-llama/llama-3.2-3b-instruct:free")
                 self.primary_model = OpenAIChatCompletionsModel(
                     model=model_name,
-                    openai_client=self.gemini_client
+                    openai_client=self.openrouter_client
                 )
                 print(f"[DEBUG] Primary model initialized successfully: {model_name}")
             except Exception as e:
@@ -87,25 +75,9 @@ class PersonalizationAgent:
                 traceback.print_exc()
                 self.primary_model = None
 
-        # Configure fallback model (OpenRouter)
-        self.fallback_model = None
-        if self.openrouter_client:
-            try:
-                # Use a working free model with fewer restrictions
-                fallback_model_name = os.getenv("OPENROUTER_MODEL", "meta-llama/llama-3.2-3b-instruct:free")
-                self.fallback_model = OpenAIChatCompletionsModel(
-                    model=fallback_model_name,
-                    openai_client=self.openrouter_client
-                )
-                print(f"[DEBUG] OpenRouter fallback configured with model: {fallback_model_name}")
-            except Exception as e:
-                print(f"[ERROR] Failed to initialize fallback model: {e}")
-                traceback.print_exc()
-                self.fallback_model = None
-
-        # Initialize 3rd fallback (OpenAI)
+        # Initialize fallback (OpenAI)
         self.openai_client = None
-        self.openai_fallback_model = None
+        self.fallback_model = None
         if os.getenv("OPENAI_API_KEY"):
             try:
                 self.openai_client = AsyncOpenAI(
@@ -114,14 +86,14 @@ class PersonalizationAgent:
                     max_retries=3
                 )
                 # User requested 'gpt-5-nano' (Hardcoded)
-                self.openai_fallback_model = OpenAIChatCompletionsModel(
+                self.fallback_model = OpenAIChatCompletionsModel(
                     model="gpt-5-nano",
                     openai_client=self.openai_client
                 )
-                print(f"[DEBUG] OpenAI 3rd fallback configured with model: gpt-5-nano")
+                print(f"[DEBUG] OpenAI fallback configured with model: gpt-5-nano")
             except Exception as e:
-                print(f"[ERROR] Failed to initialize OpenAI 3rd fallback: {e}")
-                self.openai_fallback_model = None
+                print(f"[ERROR] Failed to initialize OpenAI fallback: {e}")
+                self.fallback_model = None
 
         # Initialize the agent with primary model
         self.agent = None
@@ -249,35 +221,30 @@ class PersonalizationAgent:
             user_profile
         )
 
-        # Try primary model first (Gemini)
-        result = await self._try_personalize_with_model(
-            model_name="gemini-2.0-flash",
-            model=self.primary_model,
-            input_text=personalized_input,
-            content=content,
-            user_profile=user_profile
-        )
-
-        # If primary model failed due to quota/rate limits and fallback is available, try OpenRouter
-        if not result["success"] and self._should_use_fallback(result["error_message"]) and self.fallback_model:
-            print(f"Primary model failed, attempting fallback to OpenRouter...")
-            # Get the fallback model name from environment
-            fallback_model_name = os.getenv("OPENROUTER_MODEL", "meta-llama/llama-3.2-3b-instruct:free")
+        # Try primary model first (OpenRouter)
+        if self.primary_model:
+            primary_model_name = os.getenv("OPENROUTER_MODEL", "meta-llama/llama-3.2-3b-instruct:free")
             result = await self._try_personalize_with_model(
-                model_name=fallback_model_name,
-                model=self.fallback_model,
+                model_name=primary_model_name,
+                model=self.primary_model,
                 input_text=personalized_input,
                 content=content,
-                user_profile=user_profile,
-                is_fallback=True
+                user_profile=user_profile
             )
+        else:
+            # If no primary model, set result to failure
+            result = {
+                "success": False,
+                "error_message": "Primary model (OpenRouter) not available",
+                "model_name": "OpenRouter"
+            }
 
-        # If OpenRouter failed, try 3rd fallback (OpenAI)
-        if not result["success"] and self._should_use_fallback(result["error_message"]) and self.openai_fallback_model:
-            print(f"OpenRouter fallback failed, attempting 3rd fallback to OpenAI...")
+        # If primary model failed due to quota/rate limits and fallback is available, try OpenAI
+        if not result["success"] and self._should_use_fallback(result["error_message"]) and self.fallback_model:
+            print(f"Primary model (OpenRouter) failed, attempting fallback to OpenAI...")
             result = await self._try_personalize_with_model(
                 model_name="gpt-5-nano",
-                model=self.openai_fallback_model,
+                model=self.fallback_model,
                 input_text=personalized_input,
                 content=content,
                 user_profile=user_profile,

src/services/openai_translation/translation_agent.py

@@ -8,7 +8,6 @@ from typing import Dict, Optional, Any
 from dataclasses import dataclass
 
 from agents import Agent, Runner, AsyncOpenAI, OpenAIChatCompletionsModel
-from src.services.openai_translation.client import GeminiOpenAIClient, get_gemini_client
 from src.utils.translation_logger import get_translation_logger
 
 logger = get_translation_logger(__name__)
@@ -25,27 +24,15 @@ class TranslationContext:
 
 class OpenAITranslationAgent:
     """
-    OpenAI Agents SDK-based translation agent using proper Runner.run pattern.
+    OpenAI Agents SDK-based translation agent using OpenRouter as primary.
     """
 
-    def __init__(
-        self,
-        gemini_client: Optional[GeminiOpenAIClient] = None,
-        model: str = "gemini-2.0-flash-lite"
-    ):
-        """Initialize translation agent."""
-        self.client = gemini_client or get_gemini_client()
+    def __init__(self, model: str = "meta-llama/llama-3.2-3b-instruct:free"):
+        """Initialize translation agent with OpenRouter as primary."""
         self.model = model
 
-        # Create the agent with translation instructions
-        self.agent = Agent(
-            name="Translation Agent",
-            instructions=self._get_translation_instructions(),
-            model=self.client.get_model()
-        )
-
-        # Initialize fallback agent (OpenRouter)
-        self.fallback_agent = None
+        # Initialize primary agent (OpenRouter)
+        self.agent = None
         if os.getenv("OPENROUTER_API_KEY"):
             try:
                 openrouter_client = AsyncOpenAI(
@@ -58,24 +45,24 @@ class OpenAITranslationAgent:
                         "X-Title": "AI Book Translation Agent"
                     }
                 )
-                
-                fallback_model_name = os.getenv("OPENROUTER_MODEL", "meta-llama/llama-3.2-3b-instruct:free")
-                fallback_model = OpenAIChatCompletionsModel(
-                    model=fallback_model_name,
+
+                primary_model_name = os.getenv("OPENROUTER_MODEL", "meta-llama/llama-3.2-3b-instruct:free")
+                primary_model = OpenAIChatCompletionsModel(
+                    model=primary_model_name,
                     openai_client=openrouter_client
                 )
-                
-                self.fallback_agent = Agent(
-                    name="Translation Agent (Fallback)",
+
+                self.agent = Agent(
+                    name="Translation Agent (OpenRouter)",
                     instructions=self._get_translation_instructions(),
-                    model=fallback_model
+                    model=primary_model
                 )
-                logger.info(f"Fallback translation agent initialized with {fallback_model_name}")
+                logger.info(f"Primary translation agent initialized with {primary_model_name}")
             except Exception as e:
-                logger.error(f"Failed to initialize fallback agent: {e}")
+                logger.error(f"Failed to initialize primary agent: {e}")
 
-        # Initialize 3rd fallback agent (OpenAI)
-        self.openai_fallback_agent = None
+        # Initialize fallback agent (OpenAI)
+        self.fallback_agent = None
         if os.getenv("OPENAI_API_KEY"):
             try:
                 openai_client = AsyncOpenAI(
@@ -83,22 +70,23 @@ class OpenAITranslationAgent:
                     timeout=120.0,
                     max_retries=3
                 )
-                
-                openai_model_name = "gpt-5-nano"
-                openai_model = OpenAIChatCompletionsModel(
-                    model=openai_model_name,
+
+                fallback_model_name = "gpt-5-nano"
+                fallback_model = OpenAIChatCompletionsModel(
+                    model=fallback_model_name,
                     openai_client=openai_client
                 )
-                
-                self.openai_fallback_agent = Agent(
-                    name="Translation Agent (3rd Fallback)",
+
+                self.fallback_agent = Agent(
+                    name="Translation Agent (OpenAI Fallback)",
                     instructions=self._get_translation_instructions(),
-                    model=openai_model
+                    model=fallback_model
                 )
-                logger.info(f"3rd fallback translation agent initialized with {openai_model_name}")
+                logger.info(f"Fallback translation agent initialized with {fallback_model_name}")
             except Exception as e:
-                logger.error(f"Failed to initialize 3rd fallback agent: {e}")
+                logger.error(f"Failed to initialize fallback agent: {e}")
 
+        
     def _get_translation_instructions(self) -> str:
         """Get the base translation instructions for the agent."""
         return """
@@ -169,32 +157,22 @@ Additional context will be provided as needed for specific domains.
                     prompt,
                     max_turns=1  # Single turn for simple translation
                 )
-                model_used = self.model
+                model_used = os.getenv("OPENROUTER_MODEL", "meta-llama/llama-3.2-3b-instruct:free")
+                logger.info(f"Primary translation successful with {model_used}")
             except Exception as e:
                 # Check for fallback
                 if self.fallback_agent and self._should_use_fallback(str(e)):
-                    logger.warning(f"Primary agent failed: {e}. Attempting fallback...")
+                    logger.warning(f"Primary agent (OpenRouter) failed: {e}. Attempting OpenAI fallback...")
                     try:
                         result = await Runner.run(
                             self.fallback_agent,
                             prompt,
                             max_turns=1
                         )
-                        model_used = os.getenv("OPENROUTER_MODEL", "meta-llama/llama-3.2-3b-instruct:free")
-                        logger.info(f"Fallback translation successful with {model_used}")
+                        model_used = "gpt-5-nano"
+                        logger.info(f"OpenAI fallback translation successful with {model_used}")
                     except Exception as fallback_e:
-                        # Check for 3rd fallback
-                        if self.openai_fallback_agent and self._should_use_fallback(str(fallback_e)):
-                            logger.warning(f"OpenRouter fallback failed: {fallback_e}. Attempting 3rd fallback...")
-                            result = await Runner.run(
-                                self.openai_fallback_agent,
-                                prompt,
-                                max_turns=1
-                            )
-                            model_used = "gpt-5-nano"
-                            logger.info(f"3rd fallback translation successful with {model_used}")
-                        else:
-                            raise fallback_e
+                        raise fallback_e
                 else:
                     raise e
 
@@ -292,6 +270,6 @@ Additional context will be provided as needed for specific domains.
 
 
 # Factory function
-def create_translation_agent(model: str = "gemini-2.0-flash-lite") -> OpenAITranslationAgent:
+def create_translation_agent(model: str = "meta-llama/llama-3.2-3b-instruct:free") -> OpenAITranslationAgent:
     """Create a translation agent instance."""
     return OpenAITranslationAgent(model=model)