praisonaiagents 0.0.124__tar.gz → 0.0.125__tar.gz

{praisonaiagents-0.0.124 → praisonaiagents-0.0.125}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.124
+Version: 0.0.125
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Python: >=3.10
@@ -9,6 +9,7 @@ Requires-Dist: rich
 Requires-Dist: openai
 Requires-Dist: mcp>=1.6.0
 Requires-Dist: posthog>=3.0.0
+Requires-Dist: aiohttp>=3.8.0
 Provides-Extra: mcp
 Requires-Dist: mcp>=1.6.0; extra == "mcp"
 Requires-Dist: fastapi>=0.115.0; extra == "mcp"

{praisonaiagents-0.0.124 → praisonaiagents-0.0.125}/praisonaiagents/__init__.py

@@ -2,6 +2,30 @@
 Praison AI Agents - A package for hierarchical AI agent task execution
 """
 
+# Configure logging before any other imports
+import os
+import logging
+from rich.logging import RichHandler
+
+# Get log level from environment variable
+LOGLEVEL = os.environ.get('LOGLEVEL', 'INFO').upper()
+
+# 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
+logging.getLogger("litellm").setLevel(logging.WARNING)
+logging.getLogger("litellm.utils").setLevel(logging.WARNING)
+logging.getLogger("markdown_it").setLevel(logging.WARNING)
+logging.getLogger("rich.markdown").setLevel(logging.WARNING)
+logging.getLogger("httpx").setLevel(logging.WARNING)
+logging.getLogger("httpcore").setLevel(logging.WARNING)
+
 from .agent.agent import Agent
 from .agent.image_agent import ImageAgent
 from .agents.agents import PraisonAIAgents

{praisonaiagents-0.0.124 → praisonaiagents-0.0.125}/praisonaiagents/knowledge/knowledge.py

@@ -67,9 +67,6 @@ class Knowledge:
             
             # Disable OpenAI API request logging
             logging.getLogger('openai').setLevel(logging.WARNING)
-            
-            # Set root logger to warning to catch any uncategorized logs
-            logging.getLogger().setLevel(logging.WARNING)
 
     @cached_property
     def _deps(self):

{praisonaiagents-0.0.124 → praisonaiagents-0.0.125}/praisonaiagents/llm/__init__.py

@@ -5,19 +5,16 @@ import os
 # Disable litellm telemetry before any imports
 os.environ["LITELLM_TELEMETRY"] = "False"
 
-# Suppress all relevant logs at module level
-logging.getLogger("litellm").setLevel(logging.ERROR)
-logging.getLogger("openai").setLevel(logging.ERROR)
-logging.getLogger("httpx").setLevel(logging.ERROR)
-logging.getLogger("httpcore").setLevel(logging.ERROR)
-logging.getLogger("pydantic").setLevel(logging.ERROR)
+# Suppress all relevant logs at module level - consistent with main __init__.py
+logging.getLogger("litellm").setLevel(logging.WARNING)
+logging.getLogger("openai").setLevel(logging.WARNING)
+logging.getLogger("httpx").setLevel(logging.WARNING)
+logging.getLogger("httpcore").setLevel(logging.WARNING)
+logging.getLogger("pydantic").setLevel(logging.WARNING)
 
 # Suppress pydantic warnings
 warnings.filterwarnings("ignore", category=UserWarning, module="pydantic")
 
-# Configure logging to suppress all INFO messages
-logging.basicConfig(level=logging.WARNING)
-
 # Import after suppressing warnings
 from .llm import LLM, LLMContextLengthExceededException
 from .openai_client import (

{praisonaiagents-0.0.124 → praisonaiagents-0.0.125}/praisonaiagents/llm/llm.py

@@ -864,32 +864,44 @@ class LLM:
                         ollama_params = self._handle_ollama_model(response_text, tool_results, messages, original_prompt)
                         
                         if ollama_params:
-                            # Get response with streaming
-                            if verbose:
-                                with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
+                            # Get response based on streaming mode
+                            if stream:
+                                # Streaming approach
+                                if verbose:
+                                    with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
+                                        response_text = ""
+                                        for chunk in litellm.completion(
+                                            **self._build_completion_params(
+                                                messages=ollama_params["follow_up_messages"],
+                                                temperature=temperature,
+                                                stream=True
+                                            )
+                                        ):
+                                            if chunk and chunk.choices and chunk.choices[0].delta.content:
+                                                content = chunk.choices[0].delta.content
+                                                response_text += content
+                                                live.update(display_generating(response_text, start_time))
+                                else:
                                     response_text = ""
                                     for chunk in litellm.completion(
                                         **self._build_completion_params(
                                             messages=ollama_params["follow_up_messages"],
                                             temperature=temperature,
-                                            stream=stream
+                                            stream=True
                                         )
                                     ):
                                         if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                            content = chunk.choices[0].delta.content
-                                            response_text += content
-                                            live.update(display_generating(response_text, start_time))
+                                            response_text += chunk.choices[0].delta.content
                             else:
-                                response_text = ""
-                                for chunk in litellm.completion(
+                                # Non-streaming approach
+                                resp = litellm.completion(
                                     **self._build_completion_params(
                                         messages=ollama_params["follow_up_messages"],
                                         temperature=temperature,
-                                        stream=stream
+                                        stream=False
                                     )
-                                ):
-                                    if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                        response_text += chunk.choices[0].delta.content
+                                )
+                                response_text = resp.get("choices", [{}])[0].get("message", {}).get("content", "") or ""
                             
                             # Set flag to indicate Ollama was handled
                             ollama_handled = True
@@ -945,9 +957,26 @@ class LLM:
                         
                         # Otherwise do the existing streaming approach if not already handled
                         elif not ollama_handled:
-                            # Get response after tool calls with streaming
-                            if verbose:
-                                with Live(display_generating("", current_time), console=console, refresh_per_second=4) as live:
+                            # Get response after tool calls
+                            if stream:
+                                # Streaming approach
+                                if verbose:
+                                    with Live(display_generating("", current_time), console=console, refresh_per_second=4) as live:
+                                        final_response_text = ""
+                                        for chunk in litellm.completion(
+                                            **self._build_completion_params(
+                                                messages=messages,
+                                                tools=formatted_tools,
+                                                temperature=temperature,
+                                                stream=True,
+                                                **kwargs
+                                            )
+                                        ):
+                                            if chunk and chunk.choices and chunk.choices[0].delta.content:
+                                                content = chunk.choices[0].delta.content
+                                                final_response_text += content
+                                                live.update(display_generating(final_response_text, current_time))
+                                else:
                                     final_response_text = ""
                                     for chunk in litellm.completion(
                                         **self._build_completion_params(
@@ -959,22 +988,19 @@ class LLM:
                                         )
                                     ):
                                         if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                            content = chunk.choices[0].delta.content
-                                            final_response_text += content
-                                            live.update(display_generating(final_response_text, current_time))
+                                            final_response_text += chunk.choices[0].delta.content
                             else:
-                                final_response_text = ""
-                                for chunk in litellm.completion(
+                                # Non-streaming approach
+                                resp = litellm.completion(
                                     **self._build_completion_params(
                                         messages=messages,
                                         tools=formatted_tools,
                                         temperature=temperature,
-                                        stream=stream,
+                                        stream=False,
                                         **kwargs
                                     )
-                                ):
-                                    if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                        final_response_text += chunk.choices[0].delta.content
+                                )
+                                final_response_text = resp.get("choices", [{}])[0].get("message", {}).get("content", "") or ""
                             
                             final_response_text = final_response_text.strip()
                         

{praisonaiagents-0.0.124 → praisonaiagents-0.0.125}/praisonaiagents/main.py

@@ -9,32 +9,15 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.text import Text
 from rich.markdown import Markdown
-from rich.logging import RichHandler
 from rich.live import Live
 import asyncio
 
-# # Configure root logger
-# logging.basicConfig(level=logging.WARNING)
-
-# Suppress litellm logs
+# 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
 
-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)]
-)
-
-# Add these lines to suppress markdown parser debug logs
-logging.getLogger('markdown_it').setLevel(logging.WARNING)
-logging.getLogger('rich.markdown').setLevel(logging.WARNING)
-
 # Global list to store error logs
 error_logs = []
 

{praisonaiagents-0.0.124 → praisonaiagents-0.0.125}/praisonaiagents/mcp/mcp.py

@@ -187,15 +187,45 @@ class MCP:
         self.timeout = timeout
         self.debug = debug
         
-        # Check if this is an SSE URL
+        # Check if this is an HTTP URL
         if isinstance(command_or_string, str) and re.match(r'^https?://', command_or_string):
-            # Import the SSE client implementation
-            from .mcp_sse import SSEMCPClient
-            self.sse_client = SSEMCPClient(command_or_string, debug=debug, timeout=timeout)
-            self._tools = list(self.sse_client.tools)
-            self.is_sse = True
-            self.is_npx = False
-            return
+            # Determine transport type based on URL or kwargs
+            if command_or_string.endswith('/sse') and 'transport_type' not in kwargs:
+                # Legacy SSE URL - use SSE transport for backward compatibility
+                from .mcp_sse import SSEMCPClient
+                self.sse_client = SSEMCPClient(command_or_string, debug=debug, timeout=timeout)
+                self._tools = list(self.sse_client.tools)
+                self.is_sse = True
+                self.is_http_stream = False
+                self.is_npx = False
+                return
+            else:
+                # Use HTTP Stream transport for all other HTTP URLs
+                from .mcp_http_stream import HTTPStreamMCPClient
+                # Extract transport options from kwargs
+                transport_options = {}
+                if 'responseMode' in kwargs:
+                    transport_options['responseMode'] = kwargs.pop('responseMode')
+                if 'headers' in kwargs:
+                    transport_options['headers'] = kwargs.pop('headers')
+                if 'cors' in kwargs:
+                    transport_options['cors'] = kwargs.pop('cors')
+                if 'session' in kwargs:
+                    transport_options['session'] = kwargs.pop('session')
+                if 'resumability' in kwargs:
+                    transport_options['resumability'] = kwargs.pop('resumability')
+                
+                self.http_stream_client = HTTPStreamMCPClient(
+                    command_or_string, 
+                    debug=debug, 
+                    timeout=timeout,
+                    options=transport_options
+                )
+                self._tools = list(self.http_stream_client.tools)
+                self.is_sse = False
+                self.is_http_stream = True
+                self.is_npx = False
+                return
             
         # Handle the single string format for stdio client
         if isinstance(command_or_string, str) and args is None:
@@ -219,6 +249,7 @@ class MCP:
         
         # Set up stdio client
         self.is_sse = False
+        self.is_http_stream = False
         
         # Ensure UTF-8 encoding in environment for Docker compatibility
         env = kwargs.get('env', {})
@@ -275,6 +306,9 @@ class MCP:
         """
         if self.is_sse:
             return list(self.sse_client.tools)
+        
+        if self.is_http_stream:
+            return list(self.http_stream_client.tools)
             
         tool_functions = []
         
@@ -448,6 +482,10 @@ class MCP:
         if self.is_sse and hasattr(self, 'sse_client') and self.sse_client.tools:
             # Return all tools from SSE client
             return self.sse_client.to_openai_tools()
+        
+        if self.is_http_stream and hasattr(self, 'http_stream_client') and self.http_stream_client.tools:
+            # Return all tools from HTTP Stream client
+            return self.http_stream_client.to_openai_tools()
             
         # For simplicity, we'll convert the first tool only if multiple exist
         # More complex implementations could handle multiple tools