praisonaiagents 0.0.155__tar.gz → 0.0.157__tar.gz

{praisonaiagents-0.0.155 → praisonaiagents-0.0.157}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.155
+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.155 → praisonaiagents-0.0.157}/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,
@@ -53,6 +54,9 @@ class LLM:
     Anthropic, and others through LiteLLM.
     """
     
+    # Class-level flag for one-time logging configuration
+    _logging_configured = False
+    
     # Default window sizes for different models (75% of actual to be safe)
     MODEL_WINDOWS = {
         # OpenAI
@@ -103,6 +107,57 @@ class LLM:
     # Ollama iteration threshold for summary generation
     OLLAMA_SUMMARY_ITERATION_THRESHOLD = 1
 
+    @classmethod
+    def _configure_logging(cls):
+        """Configure logging settings once for all LLM instances."""
+        try:
+            import litellm
+            # Disable telemetry
+            litellm.telemetry = False
+            
+            # Set litellm options globally
+            litellm.set_verbose = False
+            litellm.success_callback = []
+            litellm._async_success_callback = []
+            litellm.callbacks = []
+            
+            # Suppress all litellm debug info
+            litellm.suppress_debug_info = True
+            if hasattr(litellm, '_logging'):
+                litellm._logging._disable_debugging()
+            
+            # Always suppress litellm's internal debug messages
+            logging.getLogger("litellm.utils").setLevel(logging.WARNING)
+            logging.getLogger("litellm.main").setLevel(logging.WARNING)
+            logging.getLogger("litellm.litellm_logging").setLevel(logging.WARNING)
+            logging.getLogger("litellm.transformation").setLevel(logging.WARNING)
+            
+            # Allow httpx logging when LOGLEVEL=debug, otherwise suppress it
+            loglevel = os.environ.get('LOGLEVEL', 'INFO').upper()
+            if loglevel == 'DEBUG':
+                logging.getLogger("litellm.llms.custom_httpx.http_handler").setLevel(logging.INFO)
+            else:
+                logging.getLogger("litellm.llms.custom_httpx.http_handler").setLevel(logging.WARNING)
+            
+            # Keep asyncio at WARNING unless explicitly in high debug mode
+            logging.getLogger("asyncio").setLevel(logging.WARNING)
+            logging.getLogger("selector_events").setLevel(logging.WARNING)
+            
+            # Enable error dropping for cleaner output
+            litellm.drop_params = True
+            # Enable parameter modification for providers like Anthropic
+            litellm.modify_params = True
+            
+            if hasattr(litellm, '_logging'):
+                litellm._logging._disable_debugging()
+            warnings.filterwarnings("ignore", category=RuntimeWarning)
+            
+            cls._logging_configured = True
+            
+        except ImportError:
+            # If litellm not installed, we'll handle it in __init__
+            pass
+
     def _log_llm_config(self, method_name: str, **config):
         """Centralized debug logging for LLM configuration and parameters.
         
@@ -186,47 +241,13 @@ class LLM:
         events: List[Any] = [],
         **extra_settings
     ):
+        # Configure logging only once at the class level
+        if not LLM._logging_configured:
+            LLM._configure_logging()
+            
+        # Import litellm after logging is configured
         try:
             import litellm
-            # Disable telemetry
-            litellm.telemetry = False
-            
-            # Set litellm options globally
-            litellm.set_verbose = False
-            litellm.success_callback = []
-            litellm._async_success_callback = []
-            litellm.callbacks = []
-            
-            # Suppress all litellm debug info
-            litellm.suppress_debug_info = True
-            if hasattr(litellm, '_logging'):
-                litellm._logging._disable_debugging()
-            
-            verbose = extra_settings.get('verbose', True)
-            
-            # Always suppress litellm's internal debug messages
-            # These are from external libraries and not useful for debugging user code
-            logging.getLogger("litellm.utils").setLevel(logging.WARNING)
-            logging.getLogger("litellm.main").setLevel(logging.WARNING)
-            
-            # Allow httpx logging when LOGLEVEL=debug, otherwise suppress it
-            loglevel = os.environ.get('LOGLEVEL', 'INFO').upper()
-            if loglevel == 'DEBUG':
-                logging.getLogger("litellm.llms.custom_httpx.http_handler").setLevel(logging.INFO)
-            else:
-                logging.getLogger("litellm.llms.custom_httpx.http_handler").setLevel(logging.WARNING)
-            
-            logging.getLogger("litellm.litellm_logging").setLevel(logging.WARNING)
-            logging.getLogger("litellm.transformation").setLevel(logging.WARNING)
-            litellm.suppress_debug_messages = True
-            if hasattr(litellm, '_logging'):
-                litellm._logging._disable_debugging()
-            warnings.filterwarnings("ignore", category=RuntimeWarning)
-            
-            # Keep asyncio at WARNING unless explicitly in high debug mode
-            logging.getLogger("asyncio").setLevel(logging.WARNING)
-            logging.getLogger("selector_events").setLevel(logging.WARNING)
-            
         except ImportError:
             raise ImportError(
                 "LiteLLM is required but not installed. "
@@ -252,22 +273,29 @@ class LLM:
         self.base_url = base_url
         self.events = events
         self.extra_settings = extra_settings
-        self.console = Console()
+        self._console = None  # Lazy load console when needed
         self.chat_history = []
-        self.verbose = verbose
+        self.verbose = extra_settings.get('verbose', True)
         self.markdown = extra_settings.get('markdown', True)
         self.self_reflect = extra_settings.get('self_reflect', False)
         self.max_reflect = extra_settings.get('max_reflect', 3)
         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
         self.session_token_metrics: Optional[TokenMetrics] = None
         self.current_agent_name: Optional[str] = None
         
+        # Cache for formatted tools and messages
+        self._formatted_tools_cache = {}
+        self._max_cache_size = 100
+        
         # Enable error dropping for cleaner output
+        import litellm
         litellm.drop_params = True
         # Enable parameter modification for providers like Anthropic
         litellm.modify_params = True
@@ -301,6 +329,14 @@ class LLM:
             reasoning_steps=self.reasoning_steps,
             extra_settings=self.extra_settings
         )
+    
+    @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
 
     def _is_ollama_provider(self) -> bool:
         """Detect if this is an Ollama provider regardless of naming convention"""
@@ -326,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.
@@ -625,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
@@ -733,6 +792,29 @@ class LLM:
             
         return fixed_schema
 
+    def _get_tools_cache_key(self, tools):
+        """Generate a cache key for tools list."""
+        if tools is None:
+            return "none"
+        if not tools:
+            return "empty"
+        # Create a simple hash based on tool names/content
+        tool_parts = []
+        for tool in tools:
+            if isinstance(tool, dict) and 'type' in tool and tool['type'] == 'function':
+                if 'function' in tool and isinstance(tool['function'], dict) and 'name' in tool['function']:
+                    tool_parts.append(f"openai:{tool['function']['name']}")
+            elif callable(tool) and hasattr(tool, '__name__'):
+                tool_parts.append(f"callable:{tool.__name__}")
+            elif isinstance(tool, str):
+                tool_parts.append(f"string:{tool}")
+            elif isinstance(tool, dict) and len(tool) == 1:
+                tool_name = next(iter(tool.keys()))
+                tool_parts.append(f"gemini:{tool_name}")
+            else:
+                tool_parts.append(f"other:{id(tool)}")
+        return "|".join(sorted(tool_parts))
+
     def _format_tools_for_litellm(self, tools: Optional[List[Any]]) -> Optional[List[Dict]]:
         """Format tools for LiteLLM - handles all tool formats.
         
@@ -751,6 +833,11 @@ class LLM:
         """
         if not tools:
             return None
+        
+        # Check cache first
+        tools_key = self._get_tools_cache_key(tools)
+        if tools_key in self._formatted_tools_cache:
+            return self._formatted_tools_cache[tools_key]
             
         formatted_tools = []
         for tool in tools:
@@ -808,8 +895,12 @@ class LLM:
             except (TypeError, ValueError) as e:
                 logging.error(f"Tools are not JSON serializable: {e}")
                 return None
-                
-        return formatted_tools if formatted_tools else None
+        
+        # Cache the formatted tools
+        result = formatted_tools if formatted_tools else None
+        if len(self._formatted_tools_cache) < self._max_cache_size:
+            self._formatted_tools_cache[tools_key] = result
+        return result
 
     def get_response(
         self,
@@ -956,7 +1047,7 @@ class LLM:
                         
                         # Track token usage
                         if self.metrics:
-                            self._track_token_usage(final_response, model)
+                            self._track_token_usage(final_response, self.model)
                         
                         # Execute callbacks and display based on verbose setting
                         generation_time_val = time.time() - current_time
@@ -1362,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-0.0.155 → praisonaiagents-0.0.157}/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.155 → praisonaiagents-0.0.157}/praisonaiagents.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.155
+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.155 → praisonaiagents-0.0.157}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.0.155"
+version = "0.0.157"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 requires-python = ">=3.10"
 authors = [