feat: make XML tool call parsing dynamic and configurable

- Add xml_tool_format configuration parameter (auto/true/false)
- Replace static Qwen detection with dynamic _supports_xml_tool_format() method
- Add fallback XML detection for any model outputting <tool_call> tags
- Maintain backward compatibility with existing Qwen auto-detection
- Support manual XML format enabling for any model

Fixes #1077

Co-authored-by: Mervin Praison <MervinPraison@users.noreply.github.com>

Author: github-actions[bot]

src/praisonai-agents/praisonaiagents/llm/llm.py

@@ -281,6 +281,8 @@ def __init__(
         self.min_reflect = extra_settings.get('min_reflect', 1)
         self.reasoning_steps = extra_settings.get('reasoning_steps', False)
         self.metrics = extra_settings.get('metrics', False)
+        # Auto-detect XML tool format for known models, or allow manual override
+        self.xml_tool_format = extra_settings.get('xml_tool_format', 'auto')
 
         # Token tracking
         self.last_token_metrics: Optional[TokenMetrics] = None
@@ -359,6 +361,32 @@ def _is_ollama_provider(self) -> bool:
 
         return False
 
+    def _is_qwen_provider(self) -> bool:
+        """Detect if this is a Qwen provider"""
+        if not self.model:
+            return False
+        
+        # Direct qwen/ prefix or Qwen in model name
+        model_lower = self.model.lower()
+        if any(pattern in model_lower for pattern in ["qwen", "qwen2", "qwen2.5"]):
+            return True
+        
+        # OpenAI-compatible API serving Qwen models
+        if "openai/" in self.model and any(pattern in model_lower for pattern in ["qwen", "qwen2", "qwen2.5"]):
+            return True
+            
+        return False
+
+    def _supports_xml_tool_format(self) -> bool:
+        """Check if the model should use XML tool format"""
+        if self.xml_tool_format == 'auto':
+            # Auto-detect based on known models that use XML format
+            return self._is_qwen_provider()
+        elif self.xml_tool_format is True or self.xml_tool_format == 'true':
+            return True
+        else:
+            return False
+
     def _generate_ollama_tool_summary(self, tool_results: List[Any], response_text: str) -> Optional[str]:
         """
         Generate a summary from tool results for Ollama to prevent infinite loops.
@@ -658,6 +686,10 @@ def _supports_streaming_tools(self) -> bool:
         if any(self.model.startswith(prefix) for prefix in ["gemini-", "gemini/"]):
             return True
 
+        # Models with XML tool format support streaming with tools
+        if self._supports_xml_tool_format():
+            return True
+        
         # For other providers, default to False to be safe
         # This ensures we make a single non-streaming call rather than risk
         # missing tool calls or making duplicate calls
@@ -1427,6 +1459,41 @@ def get_response(
                         except (json.JSONDecodeError, KeyError) as e:
                             logging.debug(f"Could not parse Ollama tool call from response: {e}")
 
+                    # Parse tool calls from XML format in response text 
+                    # Try for known XML models first, or fallback for any model that might output XML
+                    if not tool_calls and response_text and formatted_tools:
+                        # Check if this model is known to use XML format, or try as fallback
+                        should_try_xml = (self._supports_xml_tool_format() or 
+                                        # Fallback: try XML if response contains XML-like tool call tags
+                                        '<tool_call>' in response_text)
+                        
+                        if should_try_xml:
+                            # Look for <tool_call> XML tags
+                            tool_call_pattern = r'<tool_call>\s*({.*?})\s*</tool_call>'
+                            matches = re.findall(tool_call_pattern, response_text, re.DOTALL)
+                            
+                            if matches:
+                                tool_calls = []
+                                for idx, match in enumerate(matches):
+                                    try:
+                                        # Parse the JSON inside the XML tag
+                                        tool_json = json.loads(match.strip())
+                                        if isinstance(tool_json, dict) and "name" in tool_json:
+                                            tool_calls.append({
+                                                "id": f"tool_{iteration_count}_{idx}",
+                                                "type": "function",
+                                                "function": {
+                                                    "name": tool_json["name"],
+                                                    "arguments": json.dumps(tool_json.get("arguments", {}))
+                                                }
+                                            })
+                                    except (json.JSONDecodeError, KeyError) as e:
+                                        logging.debug(f"Could not parse XML tool call: {e}")
+                                        continue
+                                
+                                if tool_calls:
+                                    logging.debug(f"Parsed {len(tool_calls)} tool call(s) from XML format")
+                    
                     # For Ollama, if response is empty but we have tools, prompt for tool usage
                     if self._is_ollama_provider() and (not response_text or response_text.strip() == "") and formatted_tools and iteration_count == 0:
                         messages.append({