router fixed v1

llm_router.py

@@ -28,7 +28,7 @@ class LLMRouter:
             model_config = self._get_fallback_model(task_type)
             logger.info(f"Fallback model: {model_config['model_id']}")
             
-        result = await self._call_hf_endpoint(model_config, prompt, **kwargs)
+        result = await self._call_hf_endpoint(model_config, prompt, task_type, **kwargs)
         logger.info(f"Inference complete for {task_type}")
         return result
     
@@ -69,7 +69,7 @@ class LLMRouter:
         }
         return fallback_map.get(task_type, LLM_CONFIG["models"]["reasoning_primary"])
     
-    async def _call_hf_endpoint(self, model_config: dict, prompt: str, **kwargs):
+    async def _call_hf_endpoint(self, model_config: dict, prompt: str, task_type: str, **kwargs):
         """
         Make actual call to Hugging Face Chat Completions API
         Uses the correct chat completions protocol
@@ -193,7 +193,7 @@ class LLMRouter:
                 # Model is loading, retry with simpler model
                 logger.warning(f"Model loading (503), trying fallback")
                 fallback_config = self._get_fallback_model("response_synthesis")
-                return await self._call_hf_endpoint(fallback_config, prompt, **kwargs)
+                return await self._call_hf_endpoint(fallback_config, prompt, task_type, **kwargs)
             else:
                 logger.error(f"HF API error: {response.status_code} - {response.text}")
                 return None

test_task_type_fix.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""
+Test script to verify the task_type fix in LLM router
+This script tests that the NameError is resolved and the application works correctly.
+"""
+
+import logging
+import asyncio
+import sys
+import os
+
+# Add the src directory to the path
+sys.path.insert(0, '.')
+sys.path.insert(0, 'src')
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler('test_task_type_fix.log')
+    ]
+)
+
+logger = logging.getLogger(__name__)
+
+async def test_task_type_fix():
+    """Test that the task_type fix works correctly"""
+    
+    logger.info("=" * 80)
+    logger.info("TESTING TASK_TYPE FIX IN LLM ROUTER")
+    logger.info("=" * 80)
+    
+    try:
+        # Import the LLM router
+        from src.llm_router import LLMRouter
+        from src.config import settings
+        
+        logger.info("✓ Successfully imported LLM router and config")
+        
+        # Initialize LLM router with a test token
+        test_token = os.getenv('HF_TOKEN', 'test_token')
+        llm_router = LLMRouter(test_token)
+        
+        logger.info("✓ LLM router initialized")
+        
+        # Test different task types to ensure no NameError occurs
+        test_cases = [
+            ("intent_classification", "What is the user's intent?"),
+            ("response_synthesis", "Generate a response to: Hello"),
+            ("safety_check", "Is this content safe?"),
+            ("general_reasoning", "Solve this problem: 2+2"),
+        ]
+        
+        for task_type, prompt in test_cases:
+            logger.info(f"Testing task_type: {task_type}")
+            
+            try:
+                # This should not raise a NameError anymore
+                result = await llm_router.route_inference(
+                    task_type=task_type,
+                    prompt=prompt,
+                    max_tokens=50,
+                    temperature=0.7
+                )
+                
+                logger.info(f"✓ Task '{task_type}' completed successfully")
+                if result:
+                    logger.info(f"  Result length: {len(result)} characters")
+                else:
+                    logger.info("  Result: None (fallback used)")
+                    
+            except NameError as e:
+                if "task_type" in str(e):
+                    logger.error(f"✗ NameError still exists for task '{task_type}': {e}")
+                    return False
+                else:
+                    logger.warning(f"Other NameError for task '{task_type}': {e}")
+            except Exception as e:
+                logger.info(f"Expected error for task '{task_type}': {e}")
+                # This is expected since we don't have real API access
+        
+        logger.info("=" * 80)
+        logger.info("TASK_TYPE FIX VERIFICATION COMPLETED")
+        logger.info("=" * 80)
+        logger.info("✓ No NameError for 'task_type' variable")
+        logger.info("✓ All task types processed without variable errors")
+        logger.info("✓ LLM router method signature updated correctly")
+        logger.info("=" * 80)
+        
+        return True
+        
+    except ImportError as e:
+        logger.error(f"Import error: {e}")
+        logger.info("This is expected if dependencies are not available")
+        return False
+    except Exception as e:
+        logger.error(f"Test error: {e}")
+        logger.info("This indicates a problem with the fix")
+        return False
+
+def test_method_signature():
+    """Test that the method signature is correct"""
+    
+    logger.info("Testing method signature...")
+    
+    try:
+        from src.llm_router import LLMRouter
+        
+        # Check if the method signature is correct
+        import inspect
+        
+        # Get the method signature
+        method = getattr(LLMRouter, '_call_hf_endpoint')
+        signature = inspect.signature(method)
+        
+        # Check if task_type parameter exists
+        params = list(signature.parameters.keys())
+        
+        logger.info(f"Method parameters: {params}")
+        
+        if 'task_type' in params:
+            logger.info("✓ task_type parameter found in method signature")
+            return True
+        else:
+            logger.error("✗ task_type parameter missing from method signature")
+            return False
+            
+    except Exception as e:
+        logger.error(f"Method signature test failed: {e}")
+        return False
+
+if __name__ == "__main__":
+    print("Testing Task Type Fix in LLM Router")
+    print("=" * 50)
+    
+    # Test method signature first
+    signature_ok = test_method_signature()
+    
+    if signature_ok:
+        # Test the actual functionality
+        result = asyncio.run(test_task_type_fix())
+        
+        if result:
+            print("\n✅ TASK_TYPE FIX VERIFICATION PASSED")
+            print("The NameError issue has been resolved.")
+        else:
+            print("\n❌ TASK_TYPE FIX VERIFICATION FAILED")
+            print("There may still be issues with the fix.")
+    else:
+        print("\n❌ METHOD SIGNATURE TEST FAILED")
+        print("The method signature is not correct.")
+    
+    print("\nCheck 'test_task_type_fix.log' file for detailed logs.")