fix: resolve PR validation errors and improve code quality

- Fix critical linting and type errors in safe_evaluator.py
- Fix import errors in test files to match new repository structure
- Resolve 500+ linting issues (96% reduction from 5600+ to 180)
- Update test imports from mcp_servers to loan_processing.tools.mcp_servers
- Fix line length issues and code formatting
- Ensure security vulnerability fixes are properly applied
- Maintain repository separation architecture (agents/ vs tools/)

🤖 Generated with [Claude Code](https://claude.ai/code)

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

Author: niksacdev

loan_processing/__init__.py

@@ -15,17 +15,17 @@
 
 class LoanProcessingSystem:
     """Main entry point for the loan processing system with multi-provider support."""
-    
+
     def __init__(self, provider: str = "openai"):
         """
         Initialize the loan processing system with specified provider.
-        
+
         Args:
             provider: Provider name (e.g., "openai", "semantic_kernel", "autogen")
         """
         self.provider = provider
         self.engine = self._create_engine(provider)
-    
+
     def _create_engine(self, provider: str):
         """Create provider-specific orchestration engine."""
         if provider == "openai":
@@ -40,31 +40,31 @@ def _create_engine(self, provider: str):
         else:
             available_providers = ["openai", "semantic_kernel", "autogen"]
             raise ValueError(f"Unknown provider: {provider}. Available: {available_providers}")
-    
+
     async def process_application(
-        self, 
-        application: LoanApplication, 
+        self,
+        application: LoanApplication,
         pattern: str = "sequential",
-        model: Optional[str] = None
+        model: str | None = None
     ) -> LoanDecision:
         """
         Process a loan application using the configured provider.
-        
+
         Args:
             application: Loan application to process
             pattern: Orchestration pattern to use (e.g., "sequential", "parallel")
             model: Optional model override for this processing
-            
+
         Returns:
             Loan decision result
         """
         return await self.engine.execute_pattern(pattern, application, model)
-    
+
     def get_available_patterns(self) -> list[str]:
         """Get list of available orchestration patterns for this provider."""
         # This could be enhanced to dynamically discover patterns
         return ["sequential", "parallel"]
-    
+
     def get_provider_info(self) -> dict[str, str]:
         """Get information about the current provider."""
         return {
@@ -92,9 +92,9 @@ def create_autogen_system() -> LoanProcessingSystem:
 
 __all__ = [
     "LoanProcessingSystem",
-    "create_openai_system", 
+    "create_openai_system",
     "create_semantic_kernel_system",
     "create_autogen_system",
     "LoanApplication",
     "LoanDecision"
-]
+]

loan_processing/agents/__init__.py

@@ -11,4 +11,4 @@
 # Future providers will be added here:
 # AVAILABLE_PROVIDERS = ["openai", "semantic_kernel", "autogen"]
 
-__all__ = ["AVAILABLE_PROVIDERS"]
+__all__ = ["AVAILABLE_PROVIDERS"]

loan_processing/agents/providers/openai/__init__.py

@@ -5,11 +5,11 @@
 including orchestration engine, pattern executors, and agent registry.
 """
 
-from loan_processing.agents.providers.openai.orchestration.engine import OrchestrationEngine, OrchestrationContext
 from loan_processing.agents.providers.openai.agentregistry import AgentRegistry
+from loan_processing.agents.providers.openai.orchestration.engine import OrchestrationContext, OrchestrationEngine
 
 __all__ = [
     "OrchestrationEngine",
-    "OrchestrationContext", 
+    "OrchestrationContext",
     "AgentRegistry"
 ]

loan_processing/agents/providers/openai/agentregistry.py

@@ -8,9 +8,7 @@
 
 from __future__ import annotations
 
-import yaml
-from pathlib import Path
-from typing import Dict, List, Any, Optional
+from typing import Any
 
 from agents import Agent
 from agents.mcp.server import MCPServerSse
@@ -20,16 +18,16 @@
 
 class MCPServerFactory:
     """Factory for creating MCP server instances."""
-    
-    _server_cache: Dict[str, MCPServerSse] = {}
-    
+
+    _server_cache: dict[str, MCPServerSse] = {}
+
     @classmethod
     def get_server(cls, server_type: str) -> MCPServerSse:
         """Get or create an MCP server instance."""
         if server_type not in cls._server_cache:
             cls._server_cache[server_type] = cls._create_server(server_type)
         return cls._server_cache[server_type]
-    
+
     @classmethod
     def _create_server(cls, server_type: str) -> MCPServerSse:
         """Create a new MCP server instance from configuration."""
@@ -39,66 +37,66 @@ def _create_server(cls, server_type: str) -> MCPServerSse:
 
 class AgentRegistry:
     """Central registry for agent types and configurations."""
-    
+
     @classmethod
     def create_agent(cls, agent_type: str, model: str | None = None) -> Agent:
         """
         Create a configuration-driven agent instance.
-        
+
         Agents are created based on external configuration files,
         making it easy to add new agent types without code changes.
-        
+
         Args:
             agent_type: Type of agent to create (defined in agents.yaml)
             model: OpenAI model to use (e.g., "gpt-4")
-            
+
         Returns:
             Configured Agent instance without hardcoded workflow dependencies
-            
+
         Raises:
             ValueError: If agent_type is not defined in configuration
         """
         # Load agent configuration
         agent_config = ConfigurationLoader.get_agent_config(agent_type)
-        
+
         # Create MCP server instances for this agent
         mcp_servers = [
-            MCPServerFactory.get_server(server_type) 
+            MCPServerFactory.get_server(server_type)
             for server_type in agent_config["mcp_servers"]
         ]
-        
+
         # Load persona instructions (without handoff configurations)
         persona_instructions = load_persona(agent_config["persona_file"])
-        
+
         # Add structured output requirements for orchestration
         enhanced_instructions = OutputFormatGenerator.add_structured_output_instructions(
-            persona_instructions, 
+            persona_instructions,
             agent_config.get("output_format", {})
         )
-        
+
         return Agent(
             name=agent_config["name"],
             instructions=enhanced_instructions,
             model=model,
             mcp_servers=mcp_servers,
             # No handoffs - orchestrator manages workflow
         )
-    
+
     @classmethod
-    def get_agent_info(cls, agent_type: str) -> Dict[str, Any]:
+    def get_agent_info(cls, agent_type: str) -> dict[str, Any]:
         """Get information about an agent type from configuration."""
         return ConfigurationLoader.get_agent_config(agent_type).copy()
-    
+
     @classmethod
-    def list_agent_types(cls) -> List[str]:
+    def list_agent_types(cls) -> list[str]:
         """Get list of available agent types from configuration."""
         return ConfigurationLoader.list_agent_types()
-    
+
     @classmethod
-    def get_agent_capabilities(cls, agent_type: str) -> List[str]:
+    def get_agent_capabilities(cls, agent_type: str) -> list[str]:
         """Get capabilities of a specific agent type."""
         return ConfigurationLoader.get_agent_capabilities(agent_type)
-    
+
     @classmethod
     def reload_configuration(cls) -> None:
         """Force reload of configuration from disk."""
@@ -107,4 +105,4 @@ def reload_configuration(cls) -> None:
         MCPServerFactory._server_cache.clear()
 
 
-__all__ = ["AgentRegistry", "MCPServerFactory"]
+__all__ = ["AgentRegistry", "MCPServerFactory"]

loan_processing/agents/providers/openai/orchestration/__init__.py

@@ -5,17 +5,17 @@
 optimized for OpenAI Agents SDK.
 """
 
-from .engine import OrchestrationEngine, OrchestrationContext
-from .sequential import SequentialPatternExecutor
+from .base import AgentExecutionService, HandoffValidationService, PatternExecutor
+from .engine import OrchestrationContext, OrchestrationEngine
 from .parallel import ParallelPatternExecutor
-from .base import PatternExecutor, AgentExecutionService, HandoffValidationService
+from .sequential import SequentialPatternExecutor
 
 __all__ = [
-    "OrchestrationEngine", 
+    "OrchestrationEngine",
     "OrchestrationContext",
     "SequentialPatternExecutor",
     "ParallelPatternExecutor",
     "PatternExecutor",
-    "AgentExecutionService", 
+    "AgentExecutionService",
     "HandoffValidationService"
-]
+]