Update smolagents_agent.py

smolagents_agent.py

@@ -546,15 +546,18 @@ class OptimizedSmolagentsGAIAgent:
     def _initialize_model(self):
         hf_token = os.getenv("HF_TOKEN")
         if not hf_token:
-            print(" HF_TOKEN not found. Please set it in environment variables")
+            print("HF_TOKEN not found. Please set it in environment variables")
             return None
         try:
-            
-            model =  InferenceClientModel(model_id="allenai/Olmo-3-32B-Think", token=hf_token)
-            print("Using OpenAI model gpt-3.5-turbo")
+            from smolagents import InferenceClientModel
+            model = InferenceClientModel(
+                model_id="allenai/Olmo-3-32B-Think"
+                token=hf_token
+            )
+            print("Using HuggingFace model")
             return model
         except Exception as e:
-            print(f"Error initializing OpenAI model: {e}")
+            print(f"Error initializing HuggingFace model: {e}")
             return None
 
     def classify_question(self, question: str) -> Dict[str, Any]:
@@ -641,6 +644,29 @@ class OptimizedSmolagentsGAIAgent:
             result = self.agent.run(prompt)
             result_str = str(result)
             
+            # Format response for HuggingFace compatibility
+            # Wrap any code blocks in <code> tags as expected by the parsing system
+            if "```" in result_str or "def " in result_str or "import " in result_str:
+                # Extract code blocks and wrap them properly
+                import re
+                # Find Python code blocks (either fenced with ```python or ``` or plain code)
+                code_pattern = r'```(?:python)?\n(.*?)\n```|```\n(.*?)\n```|([a-zA-Z_][a-zA-Z0-9_]*\s*=\s*.*|def\s+\w+.*|import\s+\w+.*|from\s+\w+.*import.*)'
+                matches = re.findall(code_pattern, result_str, re.DOTALL)
+                
+                if matches:
+                    formatted_result = result_str
+                    for match in matches:
+                        code_content = match[0] if match[0] else match[1] if match[1] else match[2]
+                        if code_content:
+                            # Wrap in <code> tags as expected by HuggingFace parser
+                            wrapped_code = f"<code>{code_content.strip()}</code>"
+                            formatted_result = formatted_result.replace(code_content.strip(), wrapped_code)
+                    result_str = formatted_result
+                else:
+                    # If no code blocks found but response contains code-like patterns, wrap entire response
+                    if any(keyword in result_str.lower() for keyword in ['def ', 'import ', 'return ', 'print(', '# ']):
+                        result_str = f"<code>{result_str}</code>"
+            
             # Cache the result
             self.cache.set(cache_key, result_str)