fix(deps): Fix ResourceLoader dependency injection for production environments

src/python/role_play/chat/handler.py

@@ -139,18 +139,18 @@ async def _load_session_content(self, adk_session: Any, resource_loader: Resourc
             raise HTTPException(status_code=500, detail="Failed to load session character/scenario configuration.")
         return character_dict, scenario_dict
 
-    async def _generate_character_response(self, adk_session: Any, message: str, user_id: str,
-                                          session_id: str, character_dict: Dict, scenario_dict: Dict,
-                                          adk_session_service: InMemorySessionService) -> str:
+    async def _generate_character_response(self, adk_session: Any, message: str, user_id: str, session_id: str,
+                                           character_dict: Dict, scenario_dict: Dict,
+                                           adk_session_service: InMemorySessionService, resource_loader) -> str:
         """Generate character response using ADK Runner."""
         # Get character, scenario IDs and language from session state
         character_id = adk_session.state.get("character_id")
         scenario_id = adk_session.state.get("scenario_id")
         script_id = adk_session.state.get("script_id")
         language = adk_session.state.get("language", "en")
 
-        # Use get_production_agent from roleplay_agent module
-        agent = await get_production_agent(character_id, scenario_id, language, scripted=(bool(script_id) or (script_id is not None)))
+        # Use get_production_agent from roleplay_agent module with injected resource_loader
+        agent = await get_production_agent(character_id, scenario_id, language, scripted=(bool(script_id) or (script_id is not None)), resource_loader=resource_loader)
         if not agent:
             raise HTTPException(status_code=500, detail="Failed to create roleplay agent")
 
@@ -487,10 +487,9 @@ async def send_message(
             character_dict, scenario_dict = await self._load_session_content(adk_session, resource_loader)
 
             # Generate character response
-            response_text = await self._generate_character_response(
-                adk_session, request.message, current_user.id, session_id, 
-                character_dict, scenario_dict, adk_session_service
-            )
+            response_text = await self._generate_character_response(adk_session, request.message, current_user.id,
+                                                                    session_id, character_dict, scenario_dict,
+                                                                    adk_session_service, resource_loader)
 
             # Log character response
             await self._log_character_message(

src/python/role_play/dev_agents/roleplay_agent/agent.py

@@ -3,6 +3,7 @@
 """
 import os
 import sys
+import logging
 from pathlib import Path
 from typing import Dict, Optional
 from google.adk.agents import Agent
@@ -13,7 +14,9 @@
 DEFAULT_MODEL = "gemini-2.5-flash" # Set a reasonable default
 AGENT_MODEL = os.getenv("ADK_MODEL", DEFAULT_MODEL) # <-- Read from env
 
-from .tools import dev_tools, resource_loader
+logger = logging.getLogger(__name__)
+
+from .tools import dev_tools
 
 # --- Development Agent for adk web ---
 
@@ -46,7 +49,7 @@ def __init__(self, **kwargs):
 
 # --- Configuration Export for Production ---
 
-async def get_production_agent(character_id: str, scenario_id: str, language: str = "en", scripted: bool = False, agent_model: str = AGENT_MODEL) -> Optional[Agent]:
+async def get_production_agent(character_id: str, scenario_id: str, language: str = "en", scripted: bool = False, agent_model: str = AGENT_MODEL, resource_loader=None) -> Optional[Agent]:
     """
     Creates a production-ready RolePlayAgent for a specific
     character, scenario, and language.
@@ -57,10 +60,26 @@ async def get_production_agent(character_id: str, scenario_id: str, language: st
         language: The language code (e.g., "en", "zh-TW", "ja")
         scripted: whether the session is scripted or not
         agent_model: id of the llm model to use
+        resource_loader: ResourceLoader instance (injected from handler)
 
     Returns:
         A configured RolePlayAgent instance or None if character/scenario not found
     """
+    # Use the injected resource_loader or create a fallback one
+    if resource_loader is None:
+        # Try to get from dependency injection system first
+        try:
+            from ...server.dependencies import get_resource_loader
+            resource_loader = get_resource_loader()
+            logger.info(f"Using dependency-injected ResourceLoader from server")
+        except ImportError:
+            # Last resort: Use the fallback FileStorage ResourceLoader 
+            from .tools import resource_loader as fallback_loader
+            resource_loader = fallback_loader
+            logger.warning(f"Using fallback FileStorage ResourceLoader (dev only)")
+    else:
+        logger.info(f"Creating agent with {type(resource_loader).__name__}")
+
     # Use await since resource_loader methods are async
     character = await resource_loader.get_character_by_id(character_id, language)
     scenario = await resource_loader.get_scenario_by_id(scenario_id, language)

src/python/role_play/server/dependencies.py

@@ -66,7 +66,9 @@ def get_storage_backend() -> StorageBackend:
 
     # Use storage configuration
     if config.storage:
-        return create_storage_backend(config.storage, env_enum)
+        backend = create_storage_backend(config.storage, env_enum)
+        logger.info(f"Storage backend: {type(backend).__name__} for {environment}")
+        return backend
     else:
         raise ValueError("Storage configuration is required")