fix: simplify template handling by removing unnecessary processing

app.py

@@ -74,6 +74,7 @@ model = OpenAIModel(
 # Import tool from Hub
 image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
 
+# Load and validate templates from prompts.yaml
 with open("prompts.yaml", 'r') as stream:
     yaml_content = yaml.safe_load(stream)
     if not isinstance(yaml_content, dict):
@@ -84,27 +85,10 @@ with open("prompts.yaml", 'r') as stream:
     if not isinstance(prompt_templates, dict):
         raise ValueError("prompt_templates must be a dictionary")
     
-    # Process templates to ensure they are valid Jinja2 templates
-    def process_template(template_content, is_system_prompt=False):
-        """Process a template string to ensure it's properly formatted for Jinja2."""
-        if not isinstance(template_content, str):
-            return template_content
-        
-        # If it's already a template (contains {{ or {%), return as is
-        if '{{' in template_content or '{%' in template_content:
-            # Just ensure proper spacing in template expressions
-            content = template_content
-            content = re.sub(r'{{([^{}]+)}}', r'{{ \1 }}', content)
-            content = re.sub(r'{%([^{}]+)%}', r'{% \1 %}', content)
-            return content
-        
-        # For non-template strings, wrap in double curly braces
-        return f"{{{{ {template_content} }}}}"
-    
-    logger.debug("Starting template processing...")
+    logger.debug("Starting template validation...")
     try:
-        # Log the original templates
-        logger.debug("Original templates:")
+        # Log the templates
+        logger.debug("Templates:")
         for key, value in prompt_templates.items():
             if isinstance(value, dict):
                 logger.debug(f"{key}: {list(value.keys())}")
@@ -112,37 +96,25 @@ with open("prompts.yaml", 'r') as stream:
                     logger.debug(f"{key}.{subkey}: {str(subvalue)[:200]}...")
             else:
                 logger.debug(f"{key}: {str(value)[:200]}...")
-
-        prompt_templates = process_template(prompt_templates)
-        logger.debug("Template processing completed")
         
-        # Log the final processed templates
-        logger.debug("Final processed templates:")
-        for key, value in prompt_templates.items():
-            if isinstance(value, dict):
-                logger.debug(f"{key}: {list(value.keys())}")
-                for subkey, subvalue in value.items():
-                    logger.debug(f"{key}.{subkey}: {str(subvalue)[:200]}...")
-            else:
-                logger.debug(f"{key}: {str(value)[:200]}...")
-    except Exception as e:
-        logger.error(f"Error during template processing: {str(e)}")
-        raise
-
-    # Validate templates before creating agent
-    logger.debug("Validating templates...")
-    try:
+        # Validate templates
+        logger.debug("Validating templates...")
         for key, value in prompt_templates.items():
             if isinstance(value, dict):
                 for subkey, subvalue in value.items():
                     if isinstance(subvalue, str):
                         logger.debug(f"Validating template: {key}.{subkey}")
                         logger.debug(f"Template content: {subvalue[:200]}...")
-                        # Test template compilation
-                        template = Template(subvalue, undefined=StrictUndefined)
-                        # Test template rendering with dummy data
                         try:
-                            rendered = template.render(tools=[], task="test", name="test", final_answer="test", remaining_steps=1, answer_facts="test")
+                            template = Template(subvalue, undefined=StrictUndefined)
+                            rendered = template.render(
+                                tools=[],
+                                task="test",
+                                name="test",
+                                final_answer="test",
+                                remaining_steps=1,
+                                answer_facts="test"
+                            )
                             logger.debug(f"Template render test successful for {key}.{subkey}")
                             logger.debug(f"Rendered content: {rendered[:200]}...")
                         except Exception as e:
@@ -151,75 +123,39 @@ with open("prompts.yaml", 'r') as stream:
             elif isinstance(value, str):
                 logger.debug(f"Validating template: {key}")
                 logger.debug(f"Template content: {value[:200]}...")
-                template = Template(value, undefined=StrictUndefined)
                 try:
-                    rendered = template.render(tools=[], task="test", name="test", final_answer="test", remaining_steps=1, answer_facts="test")
+                    template = Template(value, undefined=StrictUndefined)
+                    rendered = template.render(
+                        tools=[],
+                        task="test",
+                        name="test",
+                        final_answer="test",
+                        remaining_steps=1,
+                        answer_facts="test"
+                    )
                     logger.debug(f"Template render test successful for {key}")
                     logger.debug(f"Rendered content: {rendered[:200]}...")
                 except Exception as e:
                     logger.error(f"Template render test failed for {key}: {str(e)}")
                     raise
+        
         logger.debug("Template validation completed successfully")
+        
     except Exception as e:
-        logger.error(f"Template validation failed: {str(e)}")
+        logger.error(f"Error during template validation: {str(e)}")
         raise
 
-    # Pre-process the system prompt template
-    if 'system_prompt' in prompt_templates and 'text' in prompt_templates['system_prompt']:
-        system_prompt = prompt_templates['system_prompt']['text']
-        logger.debug(f"Original system prompt: {system_prompt[:200]}...")
-        # Only process template variables, leave other text unchanged
-        system_prompt = re.sub(r'{{([^{}]+)}}', lambda m: '{{ ' + m.group(1).strip() + ' }}', system_prompt)
-        system_prompt = re.sub(r'{%([^{}]+)%}', lambda m: '{% ' + m.group(1).strip() + ' %}', system_prompt)
-        prompt_templates['system_prompt']['text'] = system_prompt
-        logger.debug(f"Pre-processed system prompt: {system_prompt[:200]}...")
-
-    # Log the final templates before creating the agent
-    logger.debug("Final templates before creating agent:")
-    for key, value in prompt_templates.items():
-        if isinstance(value, dict):
-            logger.debug(f"{key}:")
-            for subkey, subvalue in value.items():
-                logger.debug(f"  {subkey}: {str(subvalue)[:200]}...")
-        else:
-            logger.debug(f"{key}: {str(value)[:200]}...")
-
-    # Create a copy of the templates for the agent
-    agent_templates = {}
-    for key, value in prompt_templates.items():
-        if isinstance(value, dict):
-            agent_templates[key] = {}
-            for subkey, subvalue in value.items():
-                if isinstance(subvalue, str):
-                    # Process template with proper spacing
-                    content = process_template(subvalue, key == 'system_prompt')
-                    agent_templates[key][subkey] = content
-        elif isinstance(value, str):
-            # Process template with proper spacing
-            content = process_template(value, key == 'system_prompt')
-            agent_templates[key] = content
-        else:
-            agent_templates[key] = value
-
-    logger.debug("Templates for agent:")
-    for key, value in agent_templates.items():
-        if isinstance(value, dict):
-            logger.debug(f"{key}:")
-            for subkey, subvalue in value.items():
-                logger.debug(f"  {subkey}: {str(subvalue)[:200]}...")
-        else:
-            logger.debug(f"{key}: {str(value)[:200]}...")
-    
+# Create the agent with the templates
 agent = CodeAgent(
     model=model,
     tools=[final_answer, DuckDuckGoSearchTool(), calculate_min_price, extract_price_from_snippet, get_current_time_in_timezone],
-    max_steps=15,  # Increased max steps for more complex reasoning
-    verbosity_level=2,  # Increased verbosity for better debugging
+    max_steps=15,
+    verbosity_level=2,
     grammar=None,
-    planning_interval=1,  # Added planning interval to ensure proper planning
+    planning_interval=1,
     name="question_answering_agent",
     description="An agent specialized in answering various types of questions using available tools. The agent must use the final_answer tool to submit its answer.",
-    prompt_templates=agent_templates
+    prompt_templates=prompt_templates
 )
 
 # Configure Gradio UI with sharing enabled