praisonaiagents 0.0.146__py3-none-any.whl → 0.0.147__py3-none-any.whl

praisonaiagents/__init__.py

@@ -2,67 +2,16 @@
 Praison AI Agents - A package for hierarchical AI agent task execution
 """
 
-# Configure logging before any other imports
-import os
-import logging
-import warnings
-import re
-from rich.logging import RichHandler
+# Apply warning patch BEFORE any imports to intercept warnings at the source
+from . import _warning_patch
 
-# Set environment variables to suppress warnings at the source
-os.environ["LITELLM_TELEMETRY"] = "False"
-os.environ["LITELLM_DROP_PARAMS"] = "True"
-# Disable httpx warnings
-os.environ["HTTPX_DISABLE_WARNINGS"] = "True"
+# Import centralized logging configuration FIRST
+from . import _logging
 
-# Get log level from environment variable
-LOGLEVEL = os.environ.get('LOGLEVEL', 'INFO').upper()
-
-# Determine if warnings should be suppressed (not in DEBUG mode and not in tests)
-def _should_suppress_warnings():
-    import sys
-    return (LOGLEVEL != 'DEBUG' and 
-            not hasattr(sys, '_called_from_test') and 
-            'pytest' not in sys.modules and
-            os.environ.get('PYTEST_CURRENT_TEST') is None)
-
-# Configure root logger
-logging.basicConfig(
-    level=getattr(logging, LOGLEVEL, logging.INFO),
-    format="%(asctime)s %(filename)s:%(lineno)d %(levelname)s %(message)s",
-    datefmt="[%X]",
-    handlers=[RichHandler(rich_tracebacks=True)]
-)
-
-# Suppress specific noisy loggers - more aggressive suppression (only when not in DEBUG mode)
-if _should_suppress_warnings():
-    logging.getLogger("litellm").setLevel(logging.CRITICAL)
-    logging.getLogger("litellm_logging").setLevel(logging.CRITICAL)
-    logging.getLogger("httpx").setLevel(logging.CRITICAL)
-    logging.getLogger("httpcore").setLevel(logging.CRITICAL)
-    logging.getLogger("pydantic").setLevel(logging.WARNING)
-    logging.getLogger("markdown_it").setLevel(logging.WARNING)
-    logging.getLogger("rich.markdown").setLevel(logging.WARNING)
-
-    # Note: litellm child loggers (litellm.utils, litellm.proxy, etc.) automatically inherit 
-    # the CRITICAL level from the parent litellm logger due to Python's hierarchical logging
-
-# Comprehensive warning suppression for litellm and dependencies (issue #1033)
-# These warnings clutter output and are not actionable for users
-
-# Set warning filter to suppress all warnings from problematic modules at import time
-if _should_suppress_warnings():
-    # Module-specific warning suppression - applied before imports (only when not in DEBUG mode)
-    for module in ['litellm', 'httpx', 'httpcore', 'pydantic']:
-        warnings.filterwarnings("ignore", category=DeprecationWarning, module=module)
-        warnings.filterwarnings("ignore", category=UserWarning, module=module)
-    
-    # Specific filters for known problematic warnings
-    warnings.filterwarnings("ignore", message="There is no current event loop")
-    warnings.filterwarnings("ignore", message=".*Use 'content=<...>' to upload raw bytes/text content.*")
-    warnings.filterwarnings("ignore", message=".*The `dict` method is deprecated; use `model_dump` instead.*")
-    warnings.filterwarnings("ignore", message=".*model_dump.*deprecated.*")
+# Configure root logger after logging is initialized
+_logging.configure_root_logger()
 
+# Now import everything else
 from .agent.agent import Agent
 from .agent.image_agent import ImageAgent
 from .agent.context_agent import ContextAgent, create_context_agent
@@ -131,30 +80,6 @@ except ImportError:
 # Add Agents as an alias for PraisonAIAgents
 Agents = PraisonAIAgents
 
-# Additional warning suppression after all imports (runtime suppression)
-if _should_suppress_warnings():
-    # Try to import and configure litellm to suppress its warnings
-    try:
-        import litellm
-        # Disable all litellm logging and telemetry
-        litellm.telemetry = False
-        litellm.drop_params = True
-        # Set litellm to suppress warnings
-        litellm.suppress_debug_info = True
-        if hasattr(litellm, '_logging_obj'):
-            litellm._logging_obj.setLevel(logging.CRITICAL)
-    except (ImportError, AttributeError):
-        pass
-    
-    # Suppress pydantic warnings that might occur at runtime (safer approach)
-    try:
-        warnings.filterwarnings("ignore", category=UserWarning, module="pydantic", 
-                               message=".*model_dump.*deprecated.*")
-        warnings.filterwarnings("ignore", category=UserWarning, module="pydantic", 
-                               message=".*dict.*method.*deprecated.*")
-    except Exception:
-        pass
-
 # Apply telemetry auto-instrumentation after all imports
 if _telemetry_available:
     try:
@@ -210,4 +135,4 @@ __all__ = [
 
 # Add MCP to __all__ if available
 if _mcp_available:
-    __all__.append('MCP') 
+    __all__.append('MCP')

praisonaiagents/_logging.py

@@ -0,0 +1,134 @@
+"""
+Centralized logging configuration for PraisonAI Agents.
+This module consolidates all logging configuration in one place to avoid duplication.
+"""
+
+import os
+import logging
+from typing import List
+
+# ========================================================================
+# ENVIRONMENT CONFIGURATION
+# ========================================================================
+def _configure_environment():
+    """Set environment variables to suppress debug messages at the source."""
+    env_vars = {
+        # LiteLLM configuration
+        "LITELLM_TELEMETRY": "False",
+        "LITELLM_DROP_PARAMS": "True",
+        "LITELLM_LOG": "ERROR",
+        "LITELLM_DEBUG": "False",
+        "LITELLM_SUPPRESS_DEBUG_INFO": "True",
+        "LITELLM_VERBOSE": "False",
+        "LITELLM_SET_VERBOSE": "False",
+        # HTTPX configuration
+        "HTTPX_DISABLE_WARNINGS": "True",
+        "HTTPX_LOG_LEVEL": "ERROR",
+        # Pydantic configuration
+        "PYDANTIC_WARNINGS_ENABLED": "False",
+    }
+    
+    for key, value in env_vars.items():
+        os.environ[key] = value
+
+
+# ========================================================================
+# LOGGER CONFIGURATION
+# ========================================================================
+def _get_all_noisy_loggers() -> List[str]:
+    """Get list of all loggers that should be suppressed."""
+    return [
+        # LiteLLM and variants
+        "litellm", "LiteLLM", "LiteLLM Router", "LiteLLM Proxy",
+        # HTTP libraries
+        "httpx", "httpx._trace", "httpx._client",
+        "httpcore", "httpcore._trace",
+        # OpenAI
+        "openai._base_client", "openai._client",
+        # Markdown
+        "markdown_it", "rich.markdown",
+        # System
+        "asyncio", "selector_events", "pydantic",
+        "praisonaiagents.telemetry.telemetry",
+    ]
+
+
+def _configure_loggers():
+    """Configure all loggers based on LOGLEVEL environment variable."""
+    loglevel = os.environ.get('LOGLEVEL', 'INFO').upper()
+    
+    # When DEBUG is set, allow some HTTP logging for API endpoints
+    if loglevel == 'DEBUG':
+        allowed_debug_loggers = {"httpx._client", "openai._client"}
+        
+        for logger_name in _get_all_noisy_loggers():
+            if logger_name not in allowed_debug_loggers:
+                logger = logging.getLogger(logger_name)
+                logger.setLevel(logging.CRITICAL)
+                logger.handlers = []
+                logger.propagate = False
+        
+        # Ensure allowed loggers are at INFO level to show API calls
+        for logger_name in allowed_debug_loggers:
+            logger = logging.getLogger(logger_name)
+            logger.setLevel(logging.INFO)
+    else:
+        # Suppress all noisy loggers when not in DEBUG mode
+        for logger_name in _get_all_noisy_loggers():
+            logger = logging.getLogger(logger_name)
+            logger.setLevel(logging.CRITICAL)
+            logger.handlers = []
+            logger.propagate = False
+
+
+# ========================================================================
+# LITELLM CONFIGURATION
+# ========================================================================
+def _configure_litellm():
+    """Configure litellm after it's imported."""
+    try:
+        import litellm
+        litellm.telemetry = False
+        litellm.drop_params = True
+        litellm.suppress_debug_info = True
+        
+        if hasattr(litellm, '_logging_obj'):
+            litellm._logging_obj.setLevel(logging.CRITICAL)
+        
+        if hasattr(litellm, 'set_verbose'):
+            litellm.set_verbose = False
+            
+    except (ImportError, AttributeError):
+        pass
+
+
+# ========================================================================
+# ROOT LOGGER CONFIGURATION
+# ========================================================================
+def configure_root_logger():
+    """Configure the root logger with RichHandler."""
+    from rich.logging import RichHandler
+    
+    loglevel = os.environ.get('LOGLEVEL', 'INFO').upper()
+    
+    logging.basicConfig(
+        level=getattr(logging, loglevel, logging.INFO),
+        format="%(asctime)s %(filename)s:%(lineno)d %(levelname)s %(message)s",
+        datefmt="[%X]",
+        handlers=[RichHandler(rich_tracebacks=True)],
+        force=True
+    )
+
+
+# ========================================================================
+# INITIALIZATION
+# ========================================================================
+def initialize_logging():
+    """Initialize all logging configuration."""
+    _configure_environment()
+    _configure_loggers()
+    _configure_litellm()
+
+
+# Auto-initialize on import
+initialize_logging()

praisonaiagents/_warning_patch.py

@@ -0,0 +1,73 @@
+"""
+Minimal warning patch to suppress specific third-party warnings.
+This module patches the warnings module to intercept specific messages.
+"""
+
+import warnings
+import functools
+import sys
+
+# Apply aggressive warning filters first
+warnings.filterwarnings("ignore", message=".*Pydantic serializer warnings.*")
+warnings.filterwarnings("ignore", message=".*PydanticSerializationUnexpectedValue.*")
+warnings.filterwarnings("ignore", message=".*Expected 9 fields but got.*")
+warnings.filterwarnings("ignore", message=".*Expected `StreamingChoices` but got.*")
+warnings.filterwarnings("ignore", message=".*serialized value may not be as expected.*")
+warnings.filterwarnings("ignore", message=".*Use 'content=<...>' to upload raw bytes/text content.*")
+warnings.filterwarnings("ignore", message=".*The `dict` method is deprecated.*")
+warnings.filterwarnings("ignore", category=UserWarning, module="pydantic.*")
+
+# Store the original warn function
+_original_warn = warnings.warn
+_original_warn_explicit = warnings.warn_explicit
+
+# Messages to suppress (partial matches)
+SUPPRESSED_PATTERNS = [
+    "Use 'content=<...>' to upload raw bytes/text content",
+    "The `dict` method is deprecated; use `model_dump` instead",
+    "Pydantic serializer warnings",
+    "PydanticSerializationUnexpectedValue",
+    "Expected 9 fields but got 5 for type `Message`",
+    "Expected `StreamingChoices` but got `Choices`",
+    "serialized value may not be as expected"
+]
+
+@functools.wraps(_original_warn)
+def _patched_warn(message, category=None, stacklevel=1, source=None):
+    """Patched warn function that suppresses specific messages."""
+    msg_str = str(message)
+    
+    for pattern in SUPPRESSED_PATTERNS:
+        if pattern in msg_str:
+            return
+    
+    if category == UserWarning and "pydantic" in msg_str.lower():
+        return
+    
+    _original_warn(message, category, stacklevel, source)
+
+@functools.wraps(_original_warn_explicit)
+def _patched_warn_explicit(message, category, filename, lineno, module=None, registry=None, module_globals=None, source=None):
+    """Patched warn_explicit function that suppresses specific messages."""
+    msg_str = str(message)
+    
+    for pattern in SUPPRESSED_PATTERNS:
+        if pattern in msg_str:
+            return
+    
+    if category == UserWarning and "pydantic" in msg_str.lower():
+        return
+    
+    if module and "pydantic" in str(module):
+        return
+        
+    _original_warn_explicit(message, category, filename, lineno, module, registry, module_globals, source)
+
+# Apply the patches
+warnings.warn = _patched_warn
+warnings.warn_explicit = _patched_warn_explicit
+
+# Also patch sys.modules warnings if it exists
+if 'warnings' in sys.modules:
+    sys.modules['warnings'].warn = _patched_warn
+    sys.modules['warnings'].warn_explicit = _patched_warn_explicit

praisonaiagents/llm/__init__.py

@@ -1,38 +1,9 @@
-import logging
-import warnings
 import os
-import re
 
-# Disable litellm telemetry before any imports
+# Ensure litellm telemetry is disabled before imports
 os.environ["LITELLM_TELEMETRY"] = "False"
 
-# Check if warnings should be suppressed (consistent with main __init__.py)
-def _should_suppress_warnings():
-    import sys
-    LOGLEVEL = os.environ.get('LOGLEVEL', 'INFO').upper()
-    return (LOGLEVEL != 'DEBUG' and 
-            not hasattr(sys, '_called_from_test') and 
-            'pytest' not in sys.modules and
-            os.environ.get('PYTEST_CURRENT_TEST') is None)
-
-# Suppress all relevant logs at module level - more aggressive suppression consistent with main __init__.py (only when not in DEBUG mode)
-if _should_suppress_warnings():
-    logging.getLogger("litellm").setLevel(logging.CRITICAL)
-    logging.getLogger("openai").setLevel(logging.WARNING)
-    logging.getLogger("httpx").setLevel(logging.CRITICAL)
-    logging.getLogger("httpcore").setLevel(logging.CRITICAL)
-    logging.getLogger("pydantic").setLevel(logging.WARNING)
-
-    # Note: litellm child loggers automatically inherit the CRITICAL level from the parent logger
-
-# Warning filters are centrally managed in the main __init__.py file
-# Apply additional local suppression for safety during LLM imports (only when not in DEBUG mode)
-if _should_suppress_warnings():
-    for module in ['litellm', 'httpx', 'httpcore', 'pydantic']:
-        warnings.filterwarnings("ignore", category=DeprecationWarning, module=module)
-        warnings.filterwarnings("ignore", category=UserWarning, module=module)
-
-# Import after suppressing warnings
+# Import modules
 from .llm import LLM, LLMContextLengthExceededException
 from .openai_client import (
     OpenAIClient, 
@@ -57,22 +28,6 @@ from .model_router import (
     create_routing_agent
 )
 
-# Ensure comprehensive litellm configuration after import (only when not in DEBUG mode)
-if _should_suppress_warnings():
-    try:
-        import litellm
-        # Disable all litellm logging and telemetry features
-        litellm.telemetry = False
-        litellm.drop_params = True
-        if hasattr(litellm, 'suppress_debug_info'):
-            litellm.suppress_debug_info = True
-        # Set all litellm loggers to CRITICAL level
-        if hasattr(litellm, '_logging_obj'):
-            litellm._logging_obj.setLevel(logging.CRITICAL)
-        # Note: Child loggers inherit from parent, no need to iterate over all loggers
-    except ImportError:
-        pass
-
 __all__ = [
     "LLM", 
     "LLMContextLengthExceededException", 
@@ -92,4 +47,4 @@ __all__ = [
     "ModelProfile",
     "TaskComplexity",
     "create_routing_agent"
-]
+]

praisonaiagents/llm/llm.py

@@ -20,8 +20,7 @@ from ..main import (
 from rich.console import Console
 from rich.live import Live
 
-# Disable litellm telemetry before any imports
-os.environ["LITELLM_TELEMETRY"] = "False"
+# Logging is already configured in _logging.py via __init__.py
 
 # TODO: Include in-build tool calling in LLM class
 # TODO: Restructure so that duplicate calls are not made (Sync with agent.py)
@@ -95,7 +94,7 @@ class LLM:
     OLLAMA_FINAL_ANSWER_PROMPT = "Based on the tool results above, please provide the final answer to the original question."
     
     # Ollama iteration threshold for summary generation
-    OLLAMA_SUMMARY_ITERATION_THRESHOLD = 3
+    OLLAMA_SUMMARY_ITERATION_THRESHOLD = 1
 
     def _log_llm_config(self, method_name: str, **config):
         """Centralized debug logging for LLM configuration and parameters.
@@ -191,26 +190,28 @@ class LLM:
             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)
             
-            # Only suppress logs if not in debug mode
-            if not isinstance(verbose, bool) and verbose >= 10:
-                # Enable detailed debug logging
-                logging.getLogger("asyncio").setLevel(logging.DEBUG)
-                logging.getLogger("selector_events").setLevel(logging.DEBUG)
-                logging.getLogger("litellm.utils").setLevel(logging.DEBUG)
-                logging.getLogger("litellm.main").setLevel(logging.DEBUG)
-                litellm.suppress_debug_messages = False
-                litellm.set_verbose = True
-            else:
-                # Suppress debug logging for normal operation
-                logging.getLogger("asyncio").setLevel(logging.WARNING)
-                logging.getLogger("selector_events").setLevel(logging.WARNING)
-                logging.getLogger("litellm.utils").setLevel(logging.WARNING)
-                logging.getLogger("litellm.main").setLevel(logging.WARNING)
-                litellm.suppress_debug_messages = 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)
+            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)
+            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(
@@ -329,29 +330,47 @@ class LLM:
         # For Ollama, always generate summary when we have tool results
         # This prevents infinite loops caused by empty/minimal responses
             
-        # Build tool summary more naturally to match OpenAI-style responses
-        if len(tool_results) == 1:
+        # Filter out error results first
+        valid_results = []
+        for result in tool_results:
+            # Skip error responses
+            if isinstance(result, dict) and 'error' in result:
+                continue
+            valid_results.append(result)
+        
+        # If no valid results, return None to continue
+        if not valid_results:
+            return None
+        
+        # Generate a natural summary based on the tool results
+        if len(valid_results) == 1:
             # Single tool result - create natural response
-            result = tool_results[0]
-            if isinstance(result, dict) and 'result' in result:
-                return str(result['result'])
-            else:
-                return str(result)
+            result = valid_results[0]
+            # For simple numeric results, create a more natural response
+            if isinstance(result, (int, float)):
+                return f"The result is {result}."
+            return str(result)
         else:
             # Multiple tool results - create coherent summary
-            summary_lines = []
-            for i, result in enumerate(tool_results):
-                if isinstance(result, dict) and 'result' in result:
-                    function_name = result.get('function_name', 'Tool')
-                    summary_lines.append(f"{function_name}: {result['result']}")
-                else:
-                    summary_lines.append(f"Tool {i+1}: {result}")
+            summary_parts = []
             
-            # Create more natural summary text
-            if len(summary_lines) == 2:
-                return f"{summary_lines[0]}. {summary_lines[1]}."
-            else:
-                return "Based on the tool execution: " + ". ".join(summary_lines) + "."
+            for result in valid_results:
+                result_str = str(result)
+                # Clean up the result string
+                result_str = result_str.strip()
+                
+                # If result is just a number, keep it simple
+                if isinstance(result, (int, float)):
+                    # Don't add extra context, let the LLM's response provide that
+                    pass
+                # Ensure string results end with proper punctuation
+                elif result_str and not result_str[-1] in '.!?':
+                    result_str += '.'
+                    
+                summary_parts.append(result_str)
+            
+            # Join the parts naturally
+            return " ".join(summary_parts)
 
     def _format_ollama_tool_result_message(self, function_name: str, tool_result: Any) -> Dict[str, str]:
         """
@@ -474,7 +493,22 @@ class LLM:
             
             for param_name, param_value in arguments.items():
                 if param_name in valid_params:
-                    filtered_args[param_name] = param_value
+                    # Cast parameter value to the expected type
+                    param = sig.parameters[param_name]
+                    if param.annotation != inspect.Parameter.empty:
+                        try:
+                            if param.annotation == int and isinstance(param_value, str):
+                                filtered_args[param_name] = int(param_value)
+                            elif param.annotation == float and isinstance(param_value, str):
+                                filtered_args[param_name] = float(param_value)
+                            elif param.annotation == bool and isinstance(param_value, str):
+                                filtered_args[param_name] = param_value.lower() in ('true', '1', 'yes')
+                            else:
+                                filtered_args[param_name] = param_value
+                        except (ValueError, TypeError):
+                            filtered_args[param_name] = param_value
+                    else:
+                        filtered_args[param_name] = param_value
                 else:
                     invalid_params.append(param_name)
                     
@@ -514,19 +548,10 @@ class LLM:
         if not (self._is_ollama_provider() and iteration_count >= self.OLLAMA_SUMMARY_ITERATION_THRESHOLD):
             return False, None, iteration_count
             
-        # For Ollama: if we have meaningful tool results but empty responses,
-        # give LLM one final chance with explicit prompt for final answer
-        if accumulated_tool_results and iteration_count == self.OLLAMA_SUMMARY_ITERATION_THRESHOLD:
-            # Add explicit prompt asking for final answer
-            messages.append({
-                "role": "user", 
-                "content": self.OLLAMA_FINAL_ANSWER_PROMPT
-            })
-            # Continue to next iteration to get the final response
-            iteration_count += 1
-            return False, None, iteration_count
-        else:
-            # If still no response after final answer prompt, generate summary
+        # For Ollama: if we have meaningful tool results, generate summary immediately
+        # Don't wait for more iterations as Ollama tends to repeat tool calls
+        if accumulated_tool_results and iteration_count >= self.OLLAMA_SUMMARY_ITERATION_THRESHOLD:
+            # Generate summary from tool results
             tool_summary = self._generate_ollama_tool_summary(accumulated_tool_results, response_text)
             if tool_summary:
                 return True, tool_summary, iteration_count
@@ -874,7 +899,7 @@ class LLM:
                 if display_text and str(display_text).strip():
                     display_instruction(
                         f"Agent {agent_name} is processing prompt: {display_text}",
-                        console=console,
+                        console=self.console,
                         agent_name=agent_name,
                         agent_role=agent_role,
                         agent_tools=agent_tools
@@ -920,7 +945,7 @@ class LLM:
                                 f"Reasoning:\n{reasoning_content}\n\nAnswer:\n{response_text}",
                                 markdown=markdown,
                                 generation_time=generation_time_val,
-                                console=console,
+                                console=self.console,
                                 agent_name=agent_name,
                                 agent_role=agent_role,
                                 agent_tools=agent_tools,
@@ -936,7 +961,7 @@ class LLM:
                                 response_text,
                                 markdown=markdown,
                                 generation_time=generation_time_val,
-                                console=console,
+                                console=self.console,
                                 agent_name=agent_name,
                                 agent_role=agent_role,
                                 agent_tools=agent_tools,
@@ -971,6 +996,11 @@ class LLM:
                             # Provider doesn't support streaming with tools, use non-streaming
                             use_streaming = False
                         
+                        # Gemini has issues with streaming + tools, disable streaming for Gemini when tools are present
+                        if use_streaming and formatted_tools and self._is_gemini_model():
+                            logging.debug("Disabling streaming for Gemini model with tools due to JSON parsing issues")
+                            use_streaming = False
+                        
                         # Track whether fallback was successful to avoid duplicate API calls
                         fallback_completed = False
                         
@@ -984,7 +1014,7 @@ class LLM:
                             try:
                                 if verbose:
                                     # Verbose streaming: show display_generating during streaming
-                                    with Live(display_generating("", current_time), console=console, refresh_per_second=4) as live:
+                                    with Live(display_generating("", current_time), console=self.console, refresh_per_second=4) as live:
                                         for chunk in litellm.completion(
                                             **self._build_completion_params(
                                                 messages=messages,
@@ -1031,8 +1061,9 @@ class LLM:
                                     try:
                                         if verbose:
                                             # When verbose=True, always use streaming for better UX
-                                            with Live(display_generating("", current_time), console=console, refresh_per_second=4, transient=True) as live:
+                                            with Live(display_generating("", current_time), console=self.console, refresh_per_second=4, transient=True) as live:
                                                 response_text = ""
+                                                tool_calls = []
                                                 # Use streaming when verbose for progressive display
                                                 for chunk in litellm.completion(
                                                     **self._build_completion_params(
@@ -1047,19 +1078,20 @@ class LLM:
                                                 ):
                                                     if chunk and chunk.choices and chunk.choices[0].delta:
                                                         delta = chunk.choices[0].delta
-                                                        if hasattr(delta, "content") and delta.content:
-                                                            response_text += delta.content
-                                                            live.update(display_generating(response_text, current_time))
+                                                        response_text, tool_calls = self._process_stream_delta(
+                                                            delta, response_text, tool_calls, formatted_tools
+                                                        )
+                                                        live.update(display_generating(response_text, current_time))
                                             
                                             # Clear the live display after completion
-                                            console.print()
+                                            self.console.print()
                                             
                                             # Create final response structure
                                             final_response = {
                                                 "choices": [{
                                                     "message": {
                                                         "content": response_text,
-                                                        "tool_calls": None
+                                                        "tool_calls": tool_calls if tool_calls else None
                                                     }
                                                 }]
                                             }
@@ -1076,7 +1108,9 @@ class LLM:
                                                     **kwargs
                                                 )
                                             )
-                                            response_text = final_response["choices"][0]["message"]["content"]
+                                            # Handle None content from Gemini
+                                            response_content = final_response["choices"][0]["message"].get("content")
+                                            response_text = response_content if response_content is not None else ""
                                         
                                         # Execute callbacks and display based on verbose setting
                                         if verbose and not interaction_displayed:
@@ -1086,7 +1120,7 @@ class LLM:
                                                 response_text,
                                                 markdown=markdown,
                                                 generation_time=time.time() - current_time,
-                                                console=console,
+                                                console=self.console,
                                                 agent_name=agent_name,
                                                 agent_role=agent_role,
                                                 agent_tools=agent_tools,
@@ -1173,8 +1207,9 @@ class LLM:
                             # Non-streaming approach (when tools require it, streaming is disabled, or streaming fallback)
                             if verbose:
                                 # When verbose=True, always use streaming for better UX
-                                with Live(display_generating("", current_time), console=console, refresh_per_second=4, transient=True) as live:
+                                with Live(display_generating("", current_time), console=self.console, refresh_per_second=4, transient=True) as live:
                                     response_text = ""
+                                    tool_calls = []
                                     # Use streaming when verbose for progressive display
                                     for chunk in litellm.completion(
                                         **self._build_completion_params(
@@ -1189,19 +1224,20 @@ class LLM:
                                     ):
                                         if chunk and chunk.choices and chunk.choices[0].delta:
                                             delta = chunk.choices[0].delta
-                                            if hasattr(delta, "content") and delta.content:
-                                                response_text += delta.content
-                                                live.update(display_generating(response_text, current_time))
+                                            response_text, tool_calls = self._process_stream_delta(
+                                                delta, response_text, tool_calls, formatted_tools
+                                            )
+                                            live.update(display_generating(response_text, current_time))
                                 
                                 # Clear the live display after completion
-                                console.print()
+                                self.console.print()
                                 
                                 # Create final response structure
                                 final_response = {
                                     "choices": [{
                                         "message": {
                                             "content": response_text,
-                                            "tool_calls": None
+                                            "tool_calls": tool_calls if tool_calls else None
                                         }
                                     }]
                                 }
@@ -1218,7 +1254,9 @@ class LLM:
                                         **kwargs
                                     )
                                 )
-                                response_text = final_response["choices"][0]["message"]["content"]
+                                # Handle None content from Gemini
+                                response_content = final_response["choices"][0]["message"].get("content")
+                                response_text = response_content if response_content is not None else ""
                             
                             # Execute callbacks and display based on verbose setting
                             if verbose and not interaction_displayed:
@@ -1228,7 +1266,7 @@ class LLM:
                                     response_text,
                                     markdown=markdown,
                                     generation_time=time.time() - current_time,
-                                    console=console,
+                                    console=self.console,
                                     agent_name=agent_name,
                                     agent_role=agent_role,
                                     agent_tools=agent_tools,
@@ -1257,6 +1295,41 @@ class LLM:
                     
                     tool_calls = final_response["choices"][0]["message"].get("tool_calls")
                     
+                    
+                    # For Ollama, parse tool calls from response text if not in tool_calls field
+                    if self._is_ollama_provider() and not tool_calls and response_text and formatted_tools:
+                        # Try to parse JSON tool call from response text
+                        try:
+                            response_json = json.loads(response_text.strip())
+                            if isinstance(response_json, dict) and "name" in response_json:
+                                # Convert Ollama format to standard tool_calls format
+                                tool_calls = [{
+                                    "id": f"tool_{iteration_count}",
+                                    "type": "function",
+                                    "function": {
+                                        "name": response_json["name"],
+                                        "arguments": json.dumps(response_json.get("arguments", {}))
+                                    }
+                                }]
+                                logging.debug(f"Parsed Ollama tool call from response: {tool_calls}")
+                            elif isinstance(response_json, list):
+                                # Handle multiple tool calls
+                                tool_calls = []
+                                for idx, tool_json in enumerate(response_json):
+                                    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", {}))
+                                            }
+                                        })
+                                if tool_calls:
+                                    logging.debug(f"Parsed multiple Ollama tool calls from response: {tool_calls}")
+                        except (json.JSONDecodeError, KeyError) as e:
+                            logging.debug(f"Could not parse Ollama tool call from response: {e}")
+                    
                     # 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({
@@ -1287,6 +1360,8 @@ class LLM:
                         
                         should_continue = False
                         tool_results = []  # Store current iteration tool results
+                        tool_result_mapping = {}  # Store function results by name for Ollama chaining
+                        
                         for tool_call in tool_calls:
                             # Handle both object and dict access patterns
                             is_ollama = self._is_ollama_provider()
@@ -1294,6 +1369,15 @@ class LLM:
 
                             # Validate and filter arguments for Ollama provider
                             if is_ollama and tools:
+                                # First check if any argument references a previous tool result
+                                if is_ollama and tool_result_mapping:
+                                    # Replace function names with their results in arguments
+                                    for arg_name, arg_value in list(arguments.items()):
+                                        if isinstance(arg_value, str) and arg_value in tool_result_mapping:
+                                            # Replace function name with its result
+                                            arguments[arg_name] = tool_result_mapping[arg_value]
+                                            logging.debug(f"[OLLAMA_FIX] Replaced {arg_value} with {tool_result_mapping[arg_value]} in {function_name} arguments")
+                                
                                 arguments = self._validate_and_filter_ollama_arguments(function_name, arguments, tools)
 
                             logging.debug(f"[TOOL_EXEC_DEBUG] About to execute tool {function_name} with args: {arguments}")
@@ -1301,6 +1385,19 @@ class LLM:
                             logging.debug(f"[TOOL_EXEC_DEBUG] Tool execution result: {tool_result}")
                             tool_results.append(tool_result)  # Store the result
                             accumulated_tool_results.append(tool_result)  # Accumulate across iterations
+                            
+                            # For Ollama, store the result for potential chaining
+                            if is_ollama:
+                                # Extract numeric value from result if it contains one
+                                if isinstance(tool_result, (int, float)):
+                                    tool_result_mapping[function_name] = tool_result
+                                elif isinstance(tool_result, str):
+                                    import re
+                                    match = re.search(r'\b(\d+)\b', tool_result)
+                                    if match:
+                                        tool_result_mapping[function_name] = int(match.group(1))
+                                    else:
+                                        tool_result_mapping[function_name] = tool_result
 
                             if verbose:
                                 display_message = f"Agent {agent_name} called function '{function_name}' with arguments: {arguments}\n"
@@ -1312,7 +1409,7 @@ class LLM:
                                     logging.debug("[TOOL_EXEC_DEBUG] Tool returned no output")
                                 
                                 logging.debug(f"[TOOL_EXEC_DEBUG] About to display tool call with message: {display_message}")
-                                display_tool_call(display_message, console=console)
+                                display_tool_call(display_message, console=self.console)
                                 
                             # Check if this is Ollama provider
                             if self._is_ollama_provider():
@@ -1336,10 +1433,11 @@ class LLM:
                             iteration_count += 1
                             continue
 
-                        # Check if the LLM provided a final answer alongside the tool calls
-                        # If response_text contains substantive content, treat it as the final answer
-                        if response_text and len(response_text.strip()) > 10:
-                            # LLM provided a final answer after tool execution, don't continue
+                        # For most providers (including Gemini), we need to continue the loop
+                        # to get a final response that incorporates the tool results
+                        # Only break if the response explicitly indicates completion
+                        if response_text and len(response_text.strip()) > 50 and "final answer" in response_text.lower():
+                            # LLM provided an explicit final answer, don't continue
                             final_response_text = response_text.strip()
                             break
                         
@@ -1364,8 +1462,10 @@ class LLM:
                                 final_response_text = response_text.strip() if response_text else "Task completed."
                             break
                         
-                        # Otherwise, continue the loop to check if more tools are needed
+                        # Otherwise, continue the loop to get final response with tool results
                         iteration_count += 1
+                        # Clear response_text so we don't accidentally use the initial response
+                        response_text = ""
                         continue
                     else:
                         # No tool calls, we're done with this iteration
@@ -1381,8 +1481,12 @@ class LLM:
                                 break
                         
                         # If we've executed tools in previous iterations, this response contains the final answer
-                        if iteration_count > 0 and not final_response_text:
+                        if iteration_count > 0:
                             final_response_text = response_text.strip() if response_text else ""
+                            break
+                        
+                        # First iteration with no tool calls - just return the response
+                        final_response_text = response_text.strip() if response_text else ""
                         break
                         
                 except Exception as e:
@@ -1391,6 +1495,40 @@ class LLM:
                     
             # End of while loop - return final response
             if final_response_text:
+                # Display the final response if verbose mode is enabled
+                if verbose and not interaction_displayed:
+                    generation_time_val = time.time() - start_time
+                    display_interaction(
+                        original_prompt,
+                        final_response_text,
+                        markdown=markdown,
+                        generation_time=generation_time_val,
+                        console=self.console,
+                        agent_name=agent_name,
+                        agent_role=agent_role,
+                        agent_tools=agent_tools,
+                        task_name=task_name,
+                        task_description=task_description,
+                        task_id=task_id
+                    )
+                    interaction_displayed = True
+                    callback_executed = True
+                elif not callback_executed:
+                    # Execute callback if not already done
+                    execute_sync_callback(
+                        'interaction',
+                        message=original_prompt,
+                        response=final_response_text,
+                        markdown=markdown,
+                        generation_time=time.time() - start_time,
+                        agent_name=agent_name,
+                        agent_role=agent_role,
+                        agent_tools=agent_tools,
+                        task_name=task_name,
+                        task_description=task_description,
+                        task_id=task_id
+                    )
+                    callback_executed = True
                 return final_response_text
             
             # No tool calls were made in this iteration, return the response
@@ -1405,7 +1543,7 @@ class LLM:
                         f"Reasoning:\n{stored_reasoning_content}\n\nAnswer:\n{response_text}",
                         markdown=markdown,
                         generation_time=generation_time_val,
-                        console=console,
+                        console=self.console,
                         agent_name=agent_name,
                         agent_role=agent_role,
                         agent_tools=agent_tools,
@@ -1419,7 +1557,7 @@ class LLM:
                         response_text,
                         markdown=markdown,
                         generation_time=generation_time_val,
-                        console=console,
+                        console=self.console,
                         agent_name=agent_name,
                         agent_role=agent_role,
                         agent_tools=agent_tools,
@@ -1459,7 +1597,7 @@ class LLM:
                 
                 if verbose and not interaction_displayed:
                     display_interaction(original_prompt, response_text, markdown=markdown,
-                                     generation_time=time.time() - start_time, console=console,
+                                     generation_time=time.time() - start_time, console=self.console,
                                      agent_name=agent_name, agent_role=agent_role, agent_tools=agent_tools,
                                      task_name=task_name, task_description=task_description, task_id=task_id)
                     interaction_displayed = True
@@ -1485,7 +1623,7 @@ class LLM:
             if not self_reflect:
                 if verbose and not interaction_displayed:
                     display_interaction(original_prompt, response_text, markdown=markdown,
-                                     generation_time=time.time() - start_time, console=console,
+                                     generation_time=time.time() - start_time, console=self.console,
                                      agent_name=agent_name, agent_role=agent_role, agent_tools=agent_tools,
                                      task_name=task_name, task_description=task_description, task_id=task_id)
                     interaction_displayed = True
@@ -1551,7 +1689,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             f"{reasoning_content}\n\nReflection result:\n{reflection_text}",
                             markdown=markdown,
                             generation_time=time.time() - start_time,
-                            console=console,
+                            console=self.console,
                             agent_name=agent_name,
                             agent_role=agent_role,
                             agent_tools=agent_tools,
@@ -1565,7 +1703,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             reflection_text,
                             markdown=markdown,
                             generation_time=time.time() - start_time,
-                            console=console,
+                            console=self.console,
                             agent_name=agent_name,
                             agent_role=agent_role,
                             agent_tools=agent_tools,
@@ -1576,7 +1714,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                 else:
                     # Existing streaming approach
                     if verbose:
-                        with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
+                        with Live(display_generating("", start_time), console=self.console, refresh_per_second=4) as live:
                             reflection_text = ""
                             for chunk in litellm.completion(
                                 **self._build_completion_params(
@@ -1616,13 +1754,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     if verbose:
                         display_self_reflection(
                             f"Agent {agent_name} self reflection: reflection='{reflection_data['reflection']}' satisfactory='{reflection_data['satisfactory']}'",
-                            console=console
+                            console=self.console
                         )
 
                     if satisfactory and reflection_count >= min_reflect - 1:
                         if verbose and not interaction_displayed:
                             display_interaction(prompt, response_text, markdown=markdown,
-                                             generation_time=time.time() - start_time, console=console,
+                                             generation_time=time.time() - start_time, console=self.console,
                                              agent_name=agent_name, agent_role=agent_role, agent_tools=agent_tools,
                                              task_name=task_name, task_description=task_description, task_id=task_id)
                             interaction_displayed = True
@@ -1631,7 +1769,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     if reflection_count >= max_reflect - 1:
                         if verbose and not interaction_displayed:
                             display_interaction(prompt, response_text, markdown=markdown,
-                                             generation_time=time.time() - start_time, console=console,
+                                             generation_time=time.time() - start_time, console=self.console,
                                              agent_name=agent_name, agent_role=agent_role, agent_tools=agent_tools,
                                              task_name=task_name, task_description=task_description, task_id=task_id)
                             interaction_displayed = True
@@ -1647,7 +1785,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     
                     # Get new response after reflection
                     if verbose:
-                        with Live(display_generating("", time.time()), console=console, refresh_per_second=4) as live:
+                        with Live(display_generating("", time.time()), console=self.console, refresh_per_second=4) as live:
                             response_text = ""
                             for chunk in litellm.completion(
                                 **self._build_completion_params(
@@ -1688,7 +1826,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     if reflection_count >= max_reflect:
                         if verbose and not interaction_displayed:
                             display_interaction(prompt, response_text, markdown=markdown,
-                                             generation_time=time.time() - start_time, console=console,
+                                             generation_time=time.time() - start_time, console=self.console,
                                              agent_name=agent_name, agent_role=agent_role, agent_tools=agent_tools,
                                              task_name=task_name, task_description=task_description, task_id=task_id)
                             interaction_displayed = True
@@ -1701,7 +1839,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             # If we've exhausted reflection attempts
             if verbose and not interaction_displayed:
                 display_interaction(prompt, response_text, markdown=markdown,
-                                 generation_time=time.time() - start_time, console=console)
+                                 generation_time=time.time() - start_time, console=self.console)
                 interaction_displayed = True
             return response_text
 
@@ -2119,7 +2257,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             f"Reasoning:\n{reasoning_content}\n\nAnswer:\n{response_text}",
                             markdown=markdown,
                             generation_time=time.time() - start_time,
-                            console=console,
+                            console=self.console,
                             agent_name=agent_name,
                             agent_role=agent_role,
                             agent_tools=agent_tools,
@@ -2134,7 +2272,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             response_text,
                             markdown=markdown,
                             generation_time=time.time() - start_time,
-                            console=console,
+                            console=self.console,
                             agent_name=agent_name,
                             agent_role=agent_role,
                             agent_tools=agent_tools,
@@ -2214,9 +2352,16 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                             )
                         )
-                        response_text = tool_response.choices[0].message.get("content", "")
+                        # Handle None content from Gemini
+                        response_content = tool_response.choices[0].message.get("content")
+                        response_text = response_content if response_content is not None else ""
                         tool_calls = tool_response.choices[0].message.get("tool_calls", [])
                         
+                        # Debug logging for Gemini responses
+                        if self._is_gemini_model():
+                            logging.debug(f"Gemini response content: {response_content} -> {response_text}")
+                            logging.debug(f"Gemini tool calls: {tool_calls}")
+                        
                         if verbose and not interaction_displayed:
                             # Display the complete response at once
                             display_interaction(
@@ -2224,7 +2369,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 response_text,
                                 markdown=markdown,
                                 generation_time=time.time() - start_time,
-                                console=console,
+                                console=self.console,
                                 agent_name=agent_name,
                                 agent_role=agent_role,
                                 agent_tools=agent_tools,
@@ -2282,7 +2427,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 display_message += f"Function returned: {tool_result}"
                             else:
                                 display_message += "Function returned no output"
-                            display_tool_call(display_message, console=console)
+                            display_tool_call(display_message, console=self.console)
                         # Check if it's Ollama provider
                         if self._is_ollama_provider():
                             # For Ollama, use user role and format as natural language
@@ -2329,7 +2474,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 f"Reasoning:\n{reasoning_content}\n\nAnswer:\n{response_text}",
                                 markdown=markdown,
                                 generation_time=time.time() - start_time,
-                                console=console,
+                                console=self.console,
                                 agent_name=agent_name,
                                 agent_role=agent_role,
                                 agent_tools=agent_tools,
@@ -2344,7 +2489,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 response_text,
                                 markdown=markdown,
                                 generation_time=time.time() - start_time,
-                                console=console,
+                                console=self.console,
                                 agent_name=agent_name,
                                 agent_role=agent_role,
                                 agent_tools=agent_tools,
@@ -2455,7 +2600,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                 self.chat_history.append({"role": "assistant", "content": response_text})
                 if verbose and not interaction_displayed:
                     display_interaction(original_prompt, response_text, markdown=markdown,
-                                     generation_time=time.time() - start_time, console=console,
+                                     generation_time=time.time() - start_time, console=self.console,
                                      agent_name=agent_name, agent_role=agent_role, agent_tools=agent_tools,
                                      task_name=task_name, task_description=task_description, task_id=task_id)
                     interaction_displayed = True
@@ -2473,7 +2618,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             f"Reasoning:\n{stored_reasoning_content}\n\nAnswer:\n{display_text}",
                             markdown=markdown,
                             generation_time=time.time() - start_time,
-                            console=console,
+                            console=self.console,
                             agent_name=agent_name,
                             agent_role=agent_role,
                             agent_tools=agent_tools,
@@ -2483,7 +2628,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                         )
                     else:
                         display_interaction(original_prompt, display_text, markdown=markdown,
-                                         generation_time=time.time() - start_time, console=console,
+                                         generation_time=time.time() - start_time, console=self.console,
                                          agent_name=agent_name, agent_role=agent_role, agent_tools=agent_tools,
                                          task_name=task_name, task_description=task_description, task_id=task_id)
                     interaction_displayed = True
@@ -2530,7 +2675,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                         f"{reasoning_content}\n\nReflection result:\n{reflection_text}",
                         markdown=markdown,
                         generation_time=time.time() - start_time,
-                        console=console,
+                        console=self.console,
                         agent_name=agent_name,
                         agent_role=agent_role,
                         agent_tools=agent_tools,
@@ -2544,7 +2689,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                         reflection_text,
                         markdown=markdown,
                         generation_time=time.time() - start_time,
-                        console=console,
+                        console=self.console,
                         agent_name=agent_name,
                         agent_role=agent_role,
                         agent_tools=agent_tools,
@@ -2555,7 +2700,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             else:
                 # Existing streaming approach
                 if verbose:
-                    with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
+                    with Live(display_generating("", start_time), console=self.console, refresh_per_second=4) as live:
                         reflection_text = ""
                         async for chunk in await litellm.acompletion(
                             **self._build_completion_params(
@@ -2596,13 +2741,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     if verbose:
                         display_self_reflection(
                             f"Agent {agent_name} self reflection: reflection='{reflection_data['reflection']}' satisfactory='{reflection_data['satisfactory']}'",
-                            console=console
+                            console=self.console
                         )
 
                     if satisfactory and reflection_count >= min_reflect - 1:
                         if verbose and not interaction_displayed:
                             display_interaction(prompt, response_text, markdown=markdown,
-                                             generation_time=time.time() - start_time, console=console,
+                                             generation_time=time.time() - start_time, console=self.console,
                                              agent_name=agent_name, agent_role=agent_role, agent_tools=agent_tools,
                                              task_name=task_name, task_description=task_description, task_id=task_id)
                             interaction_displayed = True
@@ -2611,7 +2756,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     if reflection_count >= max_reflect - 1:
                         if verbose and not interaction_displayed:
                             display_interaction(prompt, response_text, markdown=markdown,
-                                             generation_time=time.time() - start_time, console=console,
+                                             generation_time=time.time() - start_time, console=self.console,
                                              agent_name=agent_name, agent_role=agent_role, agent_tools=agent_tools,
                                              task_name=task_name, task_description=task_description, task_id=task_id)
                             interaction_displayed = True

praisonaiagents/main.py

@@ -12,11 +12,7 @@ from rich.markdown import Markdown
 from rich.live import Live
 import asyncio
 
-# Logging is already configured in __init__.py, just clean up handlers for litellm
-logging.getLogger("litellm").handlers = []
-logging.getLogger("litellm.utils").handlers = []
-logging.getLogger("litellm").propagate = False
-logging.getLogger("litellm.utils").propagate = False
+# Logging is already configured in _logging.py via __init__.py
 
 # Global list to store error logs
 error_logs = []

{praisonaiagents-0.0.146.dist-info → praisonaiagents-0.0.147.dist-info}/METADATA

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

{praisonaiagents-0.0.146.dist-info → praisonaiagents-0.0.147.dist-info}/RECORD

@@ -1,6 +1,8 @@
-praisonaiagents/__init__.py,sha256=2UYF3ZisjF3gH9UTmUcMEDCnV4at3GjsKC8quewQdHI,7125
+praisonaiagents/__init__.py,sha256=pmoUafSn5f-ubjgY0rBBTw7N1wsRtg7X8-UGe477OH4,3619
+praisonaiagents/_logging.py,sha256=XvqJwqWY-W3HmYDXW_ZziZscFt98e5uyNDEPI_Hmukk,4639
+praisonaiagents/_warning_patch.py,sha256=FSLdw1SnA9b1PSxHWaRIcuG9IiIwO5JT6uo_m3CM0NI,2816
 praisonaiagents/approval.py,sha256=UJ4OhfihpFGR5CAaMphqpSvqdZCHi5w2MGw1MByZ1FQ,9813
-praisonaiagents/main.py,sha256=b5dKlkf6NMeumSzixreHB9ui90f8YMAi5r1fCbTpQVw,17225
+praisonaiagents/main.py,sha256=jT6ur_GWYZRZk0YC8xHm80Vy86y4EGk-zOv4_fc-thU,17013
 praisonaiagents/session.py,sha256=FHWButPBaFGA4x1U_2gImroQChHnFy231_aAa_n5KOQ,20364
 praisonaiagents/agent/__init__.py,sha256=KBqW_augD-HcaV3FL88gUmhDCpwnSTavGENi7RqneTo,505
 praisonaiagents/agent/agent.py,sha256=bl46q5Jl_cnR_teWdbRus7lo6-bEDwGDU9RzN5GgUNo,143159
@@ -17,8 +19,8 @@ praisonaiagents/guardrails/llm_guardrail.py,sha256=czdOIoY-3PZOchX317tz4O2h2WYE4
 praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9bge0Ujuto,246
 praisonaiagents/knowledge/chunking.py,sha256=G6wyHa7_8V0_7VpnrrUXbEmUmptlT16ISJYaxmkSgmU,7678
 praisonaiagents/knowledge/knowledge.py,sha256=OzK81oA6sjk9nAUWphS7AkXxvalrv2AHB4FtHjzYgxI,30115
-praisonaiagents/llm/__init__.py,sha256=M6peks8Yy-mnYQmbGkam2iTukn5iJAgsmPhyYAeQmR4,3197
-praisonaiagents/llm/llm.py,sha256=eBRtEcMOMMrPP3eePZ5QAU7AVgr9-ZR_dJvQnqW7JSA,163163
+praisonaiagents/llm/__init__.py,sha256=SqdU1pRqPrR6jZeWYyDeTvmZKCACywk0v4P0k5Fuowk,1107
+praisonaiagents/llm/llm.py,sha256=YeCSyohRcRbOODDW_hfvnNjRDmccA2TO9FmlFv3ohMc,172499
 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
@@ -62,7 +64,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.146.dist-info/METADATA,sha256=z97omUooPCk4RMFwbwLv5Qpgkw_bRJRbSDpn0rpxnv8,2146
-praisonaiagents-0.0.146.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-praisonaiagents-0.0.146.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.146.dist-info/RECORD,,
+praisonaiagents-0.0.147.dist-info/METADATA,sha256=f-ieQHTStmnO_SYd1AveX7hGERBTPYElLsRAAXRjxkc,2146
+praisonaiagents-0.0.147.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+praisonaiagents-0.0.147.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.147.dist-info/RECORD,,