praisonaiagents 0.0.156__py3-none-any.whl → 0.0.157__py3-none-any.whl

praisonaiagents/llm/llm.py

@@ -7,6 +7,7 @@ from typing import Any, Dict, List, Optional, Union, Literal, Callable
 from pydantic import BaseModel
 import time
 import json
+import xml.etree.ElementTree as ET
 from ..main import (
     display_error,
     display_tool_call,
@@ -281,6 +282,8 @@ class LLM:
         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 +362,25 @@ class LLM:
         
         return False
 
+    def _is_qwen_provider(self) -> bool:
+        """Detect if this is a Qwen provider"""
+        if not self.model:
+            return False
+        
+        # Check for Qwen patterns in model name
+        model_lower = self.model.lower()
+        return any(pattern in model_lower for pattern in ["qwen", "qwen2", "qwen2.5"])
+
+    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 in [True, 'true', '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 +680,10 @@ class LLM:
         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 +1453,64 @@ class LLM:
                         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:
+                            tool_calls = []
+                            
+                            # Try proper XML parsing first
+                            try:
+                                # Wrap in root element if multiple tool_call tags exist
+                                xml_content = f"<root>{response_text}</root>"
+                                root = ET.fromstring(xml_content)
+                                tool_call_elements = root.findall('.//tool_call')
+                                
+                                for idx, element in enumerate(tool_call_elements):
+                                    if element.text:
+                                        try:
+                                            tool_json = json.loads(element.text.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 tool call JSON: {e}")
+                                            continue
+                            except ET.ParseError:
+                                # Fallback to regex if XML parsing fails
+                                tool_call_pattern = r'<tool_call>\s*(\{(?:[^{}]|{[^{}]*})*\})\s*</tool_call>'
+                                matches = re.findall(tool_call_pattern, response_text, re.DOTALL)
+                                
+                                for idx, match in enumerate(matches):
+                                    try:
+                                        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({

praisonaiagents/llm/openai_client.py

@@ -230,19 +230,34 @@ class OpenAIClient:
                 f"(e.g., 'http://localhost:1234/v1') and you can use a placeholder API key by setting OPENAI_API_KEY='{LOCAL_SERVER_API_KEY_PLACEHOLDER}'"
             )
         
-        # Initialize synchronous client (lazy loading for async)
-        self._sync_client = OpenAI(api_key=self.api_key, base_url=self.base_url)
+        # Initialize clients lazily
+        self._sync_client = None
         self._async_client = None
         
         # Set up logging
         self.logger = logging.getLogger(__name__)
         
-        # Initialize console for display
-        self.console = Console()
+        # Initialize console lazily
+        self._console = None
+        
+        # Cache for formatted tools and fixed schemas
+        self._formatted_tools_cache = {}
+        self._fixed_schema_cache = {}
+        self._max_cache_size = 100
+    
+    @property
+    def console(self):
+        """Lazily initialize Rich Console only when needed."""
+        if self._console is None:
+            from rich.console import Console
+            self._console = Console()
+        return self._console
     
     @property
     def sync_client(self) -> OpenAI:
-        """Get the synchronous OpenAI client."""
+        """Get the synchronous OpenAI client (lazy initialization)."""
+        if self._sync_client is None:
+            self._sync_client = OpenAI(api_key=self.api_key, base_url=self.base_url)
         return self._sync_client
     
     @property
@@ -350,6 +365,35 @@ class OpenAIClient:
             
         return fixed_schema
     
+    def _get_tools_cache_key(self, tools: List[Any]) -> str:
+        """Generate a cache key for tools."""
+        parts = []
+        for tool in tools:
+            if isinstance(tool, dict):
+                # For dict tools, use sorted JSON representation
+                parts.append(json.dumps(tool, sort_keys=True))
+            elif callable(tool):
+                # For functions, use module.name
+                parts.append(f"{tool.__module__}.{tool.__name__}")
+            elif isinstance(tool, str):
+                # For string tools, use as-is
+                parts.append(tool)
+            elif isinstance(tool, list):
+                # For lists, recursively process
+                subparts = []
+                for subtool in tool:
+                    if isinstance(subtool, dict):
+                        subparts.append(json.dumps(subtool, sort_keys=True))
+                    elif callable(subtool):
+                        subparts.append(f"{subtool.__module__}.{subtool.__name__}")
+                    else:
+                        subparts.append(str(subtool))
+                parts.append(f"[{','.join(subparts)}]")
+            else:
+                # For other types, use string representation
+                parts.append(str(tool))
+        return "|".join(parts)
+    
     def format_tools(self, tools: Optional[List[Any]]) -> Optional[List[Dict]]:
         """
         Format tools for OpenAI API.
@@ -370,6 +414,11 @@ class OpenAIClient:
         """
         if not tools:
             return None
+        
+        # Check cache first
+        cache_key = self._get_tools_cache_key(tools)
+        if cache_key in self._formatted_tools_cache:
+            return self._formatted_tools_cache[cache_key]
             
         formatted_tools = []
         for tool in tools:
@@ -424,8 +473,13 @@ class OpenAIClient:
             except (TypeError, ValueError) as e:
                 logging.error(f"Tools are not JSON serializable: {e}")
                 return None
+        
+        # Cache the result
+        result = formatted_tools if formatted_tools else None
+        if result is not None and len(self._formatted_tools_cache) < self._max_cache_size:
+            self._formatted_tools_cache[cache_key] = result
                 
-        return formatted_tools if formatted_tools else None
+        return result
     
     def _generate_tool_definition(self, func: Callable) -> Optional[Dict]:
         """Generate a tool definition from a callable function."""
@@ -546,7 +600,7 @@ class OpenAIClient:
                 console = self.console
             
             # Create the response stream
-            response_stream = self._sync_client.chat.completions.create(
+            response_stream = self.sync_client.chat.completions.create(
                 model=model,
                 messages=messages,
                 temperature=temperature,
@@ -723,7 +777,7 @@ class OpenAIClient:
                 params["tool_choice"] = tool_choice
         
         try:
-            return self._sync_client.chat.completions.create(**params)
+            return self.sync_client.chat.completions.create(**params)
         except Exception as e:
             self.logger.error(f"Error creating completion: {e}")
             raise
@@ -1173,7 +1227,7 @@ class OpenAIClient:
         while iteration_count < max_iterations:
             try:
                 # Create streaming response
-                response_stream = self._sync_client.chat.completions.create(
+                response_stream = self.sync_client.chat.completions.create(
                     model=model,
                     messages=messages,
                     temperature=temperature,
@@ -1298,7 +1352,7 @@ class OpenAIClient:
             Parsed response according to the response_format
         """
         try:
-            response = self._sync_client.beta.chat.completions.parse(
+            response = self.sync_client.beta.chat.completions.parse(
                 model=model,
                 messages=messages,
                 temperature=temperature,
@@ -1346,14 +1400,14 @@ class OpenAIClient:
     
     def close(self):
         """Close the OpenAI clients."""
-        if hasattr(self._sync_client, 'close'):
+        if self._sync_client and hasattr(self._sync_client, 'close'):
             self._sync_client.close()
         if self._async_client and hasattr(self._async_client, 'close'):
             self._async_client.close()
     
     async def aclose(self):
         """Asynchronously close the OpenAI clients."""
-        if hasattr(self._sync_client, 'close'):
+        if self._sync_client and hasattr(self._sync_client, 'close'):
             await asyncio.to_thread(self._sync_client.close)
         if self._async_client and hasattr(self._async_client, 'aclose'):
             await self._async_client.aclose()
@@ -1361,6 +1415,7 @@ class OpenAIClient:
 
 # Global client instance (similar to main.py pattern)
 _global_client = None
+_global_client_params = None
 
 def get_openai_client(api_key: Optional[str] = None, base_url: Optional[str] = None) -> OpenAIClient:
     """
@@ -1373,9 +1428,16 @@ def get_openai_client(api_key: Optional[str] = None, base_url: Optional[str] = N
     Returns:
         OpenAIClient instance
     """
-    global _global_client
+    global _global_client, _global_client_params
+    
+    # Normalize parameters for comparison
+    normalized_api_key = api_key or os.getenv("OPENAI_API_KEY")
+    normalized_base_url = base_url
+    current_params = (normalized_api_key, normalized_base_url)
     
-    if _global_client is None:
+    # Only create new client if parameters changed or first time
+    if _global_client is None or _global_client_params != current_params:
         _global_client = OpenAIClient(api_key=api_key, base_url=base_url)
+        _global_client_params = current_params
     
     return _global_client

{praisonaiagents-0.0.156.dist-info → praisonaiagents-0.0.157.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.156
+Version: 0.0.157
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Python: >=3.10

{praisonaiagents-0.0.156.dist-info → praisonaiagents-0.0.157.dist-info}/RECORD

@@ -21,10 +21,10 @@ praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9b
 praisonaiagents/knowledge/chunking.py,sha256=G6wyHa7_8V0_7VpnrrUXbEmUmptlT16ISJYaxmkSgmU,7678
 praisonaiagents/knowledge/knowledge.py,sha256=tog38b0SjFMoLuFBo0M1zHl9Dzzxa9YRv9FO7OZSpns,30587
 praisonaiagents/llm/__init__.py,sha256=SqdU1pRqPrR6jZeWYyDeTvmZKCACywk0v4P0k5Fuowk,1107
-praisonaiagents/llm/llm.py,sha256=4bFBazXH6TSHKt1-V6UNivf22_uVJXEwovWMpvPmYYg,179165
+praisonaiagents/llm/llm.py,sha256=C4C1xrR_qgInbgF1I-YhgPLI1C1YYI-5u3vn6Gp8sVc,184239
 praisonaiagents/llm/model_capabilities.py,sha256=cxOvZcjZ_PIEpUYKn3S2FMyypfOSfbGpx4vmV7Y5vhI,3967
 praisonaiagents/llm/model_router.py,sha256=Jy2pShlkLxqXF3quz-MRB3-6L9vaUSgUrf2YJs_Tsg0,13995
-praisonaiagents/llm/openai_client.py,sha256=3EVjIs3tnBNFDy_4ZxX9DJVq54kS0FMm38m5Gkpun7U,57234
+praisonaiagents/llm/openai_client.py,sha256=Qn4z_ld8IYe-R8yKDRuek_4CP8lCJz2blJIRTm-mfDg,59882
 praisonaiagents/mcp/__init__.py,sha256=ibbqe3_7XB7VrIcUcetkZiUZS1fTVvyMy_AqCSFG8qc,240
 praisonaiagents/mcp/mcp.py,sha256=ChaSwLCcFBB9b8eNuj0DoKbK1EqpyF1T_7xz0FX-5-A,23264
 praisonaiagents/mcp/mcp_http_stream.py,sha256=TDFWMJMo8VqLXtXCW73REpmkU3t9n7CAGMa9b4dhI-c,23366
@@ -67,7 +67,7 @@ praisonaiagents/tools/xml_tools.py,sha256=iYTMBEk5l3L3ryQ1fkUnNVYK-Nnua2Kx2S0dxN
 praisonaiagents/tools/yaml_tools.py,sha256=uogAZrhXV9O7xvspAtcTfpKSQYL2nlOTvCQXN94-G9A,14215
 praisonaiagents/tools/yfinance_tools.py,sha256=s2PBj_1v7oQnOobo2fDbQBACEHl61ftG4beG6Z979ZE,8529
 praisonaiagents/tools/train/data/generatecot.py,sha256=H6bNh-E2hqL5MW6kX3hqZ05g9ETKN2-kudSjiuU_SD8,19403
-praisonaiagents-0.0.156.dist-info/METADATA,sha256=I3PDqNvozu1_arRs4qEUh72poDF_Zi5yoUtZVPGwPB0,2146
-praisonaiagents-0.0.156.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-praisonaiagents-0.0.156.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.156.dist-info/RECORD,,
+praisonaiagents-0.0.157.dist-info/METADATA,sha256=Ww1hB8QIFxzqu7UXFL7B5OscEFYl8UIGPnR8FuiUFLU,2146
+praisonaiagents-0.0.157.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+praisonaiagents-0.0.157.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.157.dist-info/RECORD,,