praisonaiagents 0.0.124__py3-none-any.whl → 0.0.125__py3-none-any.whl

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/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/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/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/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/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

praisonaiagents/mcp/mcp_http_stream.py

@@ -0,0 +1,466 @@
+"""
+HTTP Stream client implementation for MCP (Model Context Protocol).
+This module provides the necessary classes and functions to connect to an MCP server
+over HTTP Stream transport, implementing the Streamable HTTP transport protocol.
+"""
+
+import asyncio
+import logging
+import threading
+import inspect
+import json
+import time
+import uuid
+from typing import List, Dict, Any, Optional, Callable, Iterable, Union
+from urllib.parse import urlparse, urljoin
+
+from mcp import ClientSession
+try:
+    import aiohttp
+except ImportError:
+    raise ImportError("aiohttp is required for HTTP Stream transport. Install with: pip install praisonaiagents[mcp]")
+
+logger = logging.getLogger("mcp-http-stream")
+
+# Global event loop for async operations
+_event_loop = None
+
+def get_event_loop():
+    """Get or create a global event loop."""
+    global _event_loop
+    if _event_loop is None or _event_loop.is_closed():
+        _event_loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(_event_loop)
+    return _event_loop
+
+
+class HTTPStreamMCPTool:
+    """A wrapper for an MCP tool that can be used with praisonaiagents."""
+    
+    def __init__(self, name: str, description: str, session: ClientSession, input_schema: Optional[Dict[str, Any]] = None, timeout: int = 60):
+        self.name = name
+        self.__name__ = name  # Required for Agent to recognize it as a tool
+        self.__qualname__ = name  # Required for Agent to recognize it as a tool
+        self.__doc__ = description  # Required for Agent to recognize it as a tool
+        self.description = description
+        self.session = session
+        self.input_schema = input_schema or {}
+        self.timeout = timeout
+        
+        # Create a signature based on input schema
+        params = []
+        if input_schema and 'properties' in input_schema:
+            for param_name, prop_schema in input_schema['properties'].items():
+                # Determine type annotation based on schema
+                prop_type = prop_schema.get('type', 'string') if isinstance(prop_schema, dict) else 'string'
+                if prop_type == 'string':
+                    annotation = str
+                elif prop_type == 'integer':
+                    annotation = int
+                elif prop_type == 'number':
+                    annotation = float
+                elif prop_type == 'boolean':
+                    annotation = bool
+                elif prop_type == 'array':
+                    annotation = list
+                elif prop_type == 'object':
+                    annotation = dict
+                else:
+                    annotation = Any
+                
+                params.append(
+                    inspect.Parameter(
+                        name=param_name,
+                        kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                        default=inspect.Parameter.empty if param_name in input_schema.get('required', []) else None,
+                        annotation=annotation
+                    )
+                )
+        
+        self.__signature__ = inspect.Signature(params)
+        
+    def __call__(self, **kwargs):
+        """Synchronous wrapper for the async call."""
+        logger.debug(f"Tool {self.name} called with args: {kwargs}")
+        
+        # Use the global event loop
+        loop = get_event_loop()
+        
+        # Run the async call in the event loop
+        future = asyncio.run_coroutine_threadsafe(self._async_call(**kwargs), loop)
+        try:
+            # Wait for the result with a timeout
+            return future.result(timeout=self.timeout)
+        except Exception as e:
+            logger.error(f"Error calling tool {self.name}: {e}")
+            return f"Error: {str(e)}"
+    
+    async def _async_call(self, **kwargs):
+        """Call the tool with the provided arguments."""
+        logger.debug(f"Async calling tool {self.name} with args: {kwargs}")
+        try:
+            result = await self.session.call_tool(self.name, kwargs)
+            
+            # Extract text from result
+            if hasattr(result, 'content') and result.content:
+                if hasattr(result.content[0], 'text'):
+                    return result.content[0].text
+                return str(result.content[0])
+            return str(result)
+        except Exception as e:
+            logger.error(f"Error in _async_call for {self.name}: {e}")
+            raise
+    
+    def _fix_array_schemas(self, schema):
+        """
+        Fix array schemas by adding missing 'items' attribute required by OpenAI.
+        
+        This ensures compatibility with OpenAI's function calling format which
+        requires array types to specify the type of items they contain.
+        
+        Args:
+            schema: The schema dictionary to fix
+            
+        Returns:
+            dict: The fixed schema
+        """
+        if not isinstance(schema, dict):
+            return schema
+            
+        # Create a copy to avoid modifying the original
+        fixed_schema = schema.copy()
+        
+        # Fix array types at the current level
+        if fixed_schema.get("type") == "array" and "items" not in fixed_schema:
+            # Add a default items schema for arrays without it
+            fixed_schema["items"] = {"type": "string"}
+            
+        # Recursively fix nested schemas
+        if "properties" in fixed_schema:
+            fixed_properties = {}
+            for prop_name, prop_schema in fixed_schema["properties"].items():
+                fixed_properties[prop_name] = self._fix_array_schemas(prop_schema)
+            fixed_schema["properties"] = fixed_properties
+            
+        # Fix items schema if it exists
+        if "items" in fixed_schema:
+            fixed_schema["items"] = self._fix_array_schemas(fixed_schema["items"])
+            
+        return fixed_schema
+    
+    def to_openai_tool(self):
+        """Convert the tool to OpenAI format."""
+        # Fix array schemas to include 'items' attribute
+        fixed_schema = self._fix_array_schemas(self.input_schema)
+        
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": fixed_schema
+            }
+        }
+
+
+class HTTPStreamTransport:
+    """
+    HTTP Stream Transport implementation for MCP.
+    
+    This transport provides a single endpoint for all MCP communication,
+    supporting both batch (JSON) and streaming (SSE) response modes.
+    """
+    
+    def __init__(self, base_url: str, session_id: Optional[str] = None, options: Optional[Dict[str, Any]] = None):
+        self.base_url = base_url
+        self.session_id = session_id
+        self.options = options or {}
+        self.response_mode = self.options.get('responseMode', 'batch')
+        self.headers = {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json, text/event-stream'
+        }
+        if session_id:
+            self.headers['Mcp-Session-Id'] = session_id
+        
+        # Add custom headers if provided
+        if 'headers' in self.options:
+            self.headers.update(self.options['headers'])
+        
+        self._session = None
+        self._sse_task = None
+        self._message_queue = asyncio.Queue()
+        self._pending_requests = {}
+        self._closing = False
+        
+    async def __aenter__(self):
+        self._session = aiohttp.ClientSession()
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        # Set closing flag to stop listener gracefully
+        self._closing = True
+        
+        if self._sse_task:
+            self._sse_task.cancel()
+            try:
+                await self._sse_task
+            except asyncio.CancelledError:
+                pass
+        if self._session:
+            await self._session.close()
+    
+    async def send_request(self, request: Dict[str, Any]) -> Union[Dict[str, Any], None]:
+        """Send a request to the HTTP Stream endpoint."""
+        if not self._session:
+            raise RuntimeError("Transport not initialized. Use async context manager.")
+        
+        try:
+            async with self._session.post(self.base_url, json=request, headers=self.headers) as response:
+                # Update session ID if provided in response
+                if 'Mcp-Session-Id' in response.headers:
+                    self.session_id = response.headers['Mcp-Session-Id']
+                    self.headers['Mcp-Session-Id'] = self.session_id
+                
+                # Handle different response types
+                content_type = response.headers.get('Content-Type', '')
+                
+                if 'text/event-stream' in content_type:
+                    # Stream mode - process SSE events
+                    return await self._process_sse_response(response)
+                else:
+                    # Batch mode - return JSON response
+                    return await response.json()
+                    
+        except Exception as e:
+            logger.error(f"Error sending request: {e}")
+            raise
+    
+    async def _process_sse_response(self, response):
+        """Process SSE response stream."""
+        buffer = ""
+        async for chunk in response.content:
+            buffer += chunk.decode('utf-8')
+            
+            # Process complete SSE events
+            while "\n\n" in buffer:
+                event, buffer = buffer.split("\n\n", 1)
+                lines = event.strip().split("\n")
+                
+                # Parse SSE event
+                data = None
+                for line in lines:
+                    if line.startswith("data: "):
+                        data = line[6:]  # Remove "data: " prefix
+                
+                if data:
+                    try:
+                        message = json.loads(data)
+                        # Process the message
+                        if 'id' in message and message['id'] in self._pending_requests:
+                            # This is a response to a pending request
+                            self._pending_requests[message['id']].set_result(message)
+                        else:
+                            # This is a server-initiated message
+                            await self._message_queue.put(message)
+                    except json.JSONDecodeError:
+                        logger.error(f"Failed to parse SSE event: {data}")
+    
+    async def start_sse_listener(self):
+        """Start listening for SSE events from the server."""
+        if self._sse_task is None or self._sse_task.done():
+            self._sse_task = asyncio.create_task(self._sse_listener())
+    
+    async def _sse_listener(self):
+        """Background task to listen for SSE events."""
+        while True:
+            try:
+                # Check if we should stop
+                if hasattr(self, '_closing') and self._closing:
+                    break
+                    
+                url = self.base_url
+                if self.session_id:
+                    # Add session as query parameter for SSE connection
+                    url = f"{url}?session={self.session_id}"
+                
+                headers = {
+                    'Accept': 'text/event-stream',
+                    'Cache-Control': 'no-cache'
+                }
+                if self.session_id:
+                    headers['Mcp-Session-Id'] = self.session_id
+                
+                async with self._session.get(url, headers=headers) as response:
+                    buffer = ""
+                    async for chunk in response.content:
+                        # Check if we should stop
+                        if hasattr(self, '_closing') and self._closing:
+                            break
+                            
+                        buffer += chunk.decode('utf-8')
+                        
+                        # Process complete SSE events
+                        while "\n\n" in buffer:
+                            event, buffer = buffer.split("\n\n", 1)
+                            lines = event.strip().split("\n")
+                            
+                            # Parse SSE event
+                            data = None
+                            for line in lines:
+                                if line.startswith("data: "):
+                                    data = line[6:]  # Remove "data: " prefix
+                            
+                            if data:
+                                try:
+                                    message = json.loads(data)
+                                    await self._message_queue.put(message)
+                                except json.JSONDecodeError:
+                                    logger.error(f"Failed to parse SSE event: {data}")
+                                
+            except asyncio.CancelledError:
+                # Proper shutdown
+                break
+            except Exception as e:
+                if not (hasattr(self, '_closing') and self._closing):
+                    logger.error(f"SSE listener error: {e}")
+                    await asyncio.sleep(1)  # Reconnect after 1 second
+                else:
+                    break
+    
+    def read_stream(self):
+        """Create a read stream for the ClientSession."""
+        async def _read():
+            while True:
+                message = await self._message_queue.get()
+                yield message
+        return _read()
+    
+    def write_stream(self):
+        """Create a write stream for the ClientSession."""
+        async def _write(message):
+            if hasattr(message, 'to_dict'):
+                message = message.to_dict()
+            response = await self.send_request(message)
+            return response
+        return _write
+
+
+class HTTPStreamMCPClient:
+    """A client for connecting to an MCP server over HTTP Stream transport."""
+    
+    def __init__(self, server_url: str, debug: bool = False, timeout: int = 60, options: Optional[Dict[str, Any]] = None):
+        """
+        Initialize an HTTP Stream MCP client.
+        
+        Args:
+            server_url: The URL of the HTTP Stream MCP server
+            debug: Whether to enable debug logging
+            timeout: Timeout in seconds for operations (default: 60)
+            options: Additional configuration options for the transport
+        """
+        # Parse URL to extract base URL and endpoint
+        parsed = urlparse(server_url)
+        
+        # If the URL already has a path, use it; otherwise use default /mcp endpoint
+        if parsed.path and parsed.path != '/':
+            self.base_url = server_url
+        else:
+            # Default endpoint is /mcp
+            self.base_url = urljoin(server_url, '/mcp')
+        
+        self.debug = debug
+        self.timeout = timeout
+        self.options = options or {}
+        self.session = None
+        self.tools = []
+        self.transport = None
+        
+        # Set up logging
+        if debug:
+            logger.setLevel(logging.DEBUG)
+        else:
+            # Set to WARNING by default to hide INFO messages
+            logger.setLevel(logging.WARNING)
+        
+        self._initialize()
+        
+    def _initialize(self):
+        """Initialize the connection and tools."""
+        # Use the global event loop
+        loop = get_event_loop()
+        
+        # Start a background thread to run the event loop
+        def run_event_loop():
+            asyncio.set_event_loop(loop)
+            loop.run_forever()
+        
+        self.loop_thread = threading.Thread(target=run_event_loop, daemon=True)
+        self.loop_thread.start()
+        
+        # Run the initialization in the event loop
+        future = asyncio.run_coroutine_threadsafe(self._async_initialize(), loop)
+        self.tools = future.result(timeout=self.timeout)
+    
+    async def _async_initialize(self):
+        """Asynchronously initialize the connection and tools."""
+        logger.debug(f"Connecting to MCP server at {self.base_url}")
+        
+        # Create HTTP Stream transport
+        self.transport = HTTPStreamTransport(self.base_url, options=self.options)
+        await self.transport.__aenter__()
+        
+        # Create read and write streams
+        read_stream = self.transport.read_stream()
+        write_stream = self.transport.write_stream()
+        
+        # Start SSE listener if in stream mode
+        if self.options.get('responseMode', 'batch') == 'stream':
+            await self.transport.start_sse_listener()
+        
+        # Create client session
+        self._session_context = ClientSession(read_stream, write_stream)
+        self.session = await self._session_context.__aenter__()
+        
+        # Initialize
+        await self.session.initialize()
+        
+        # List available tools
+        logger.debug("Listing tools...")
+        response = await self.session.list_tools()
+        tools_data = response.tools
+        logger.debug(f"Found {len(tools_data)} tools: {[tool.name for tool in tools_data]}")
+        
+        # Create tool wrappers
+        tools = []
+        for tool in tools_data:
+            input_schema = tool.inputSchema if hasattr(tool, 'inputSchema') else None
+            wrapper = HTTPStreamMCPTool(
+                name=tool.name,
+                description=tool.description if hasattr(tool, 'description') else f"Call the {tool.name} tool",
+                session=self.session,
+                input_schema=input_schema,
+                timeout=self.timeout
+            )
+            tools.append(wrapper)
+            
+        return tools
+    
+    def __iter__(self):
+        """Return an iterator over the tools."""
+        return iter(self.tools)
+    
+    def to_openai_tools(self):
+        """Convert all tools to OpenAI format."""
+        return [tool.to_openai_tool() for tool in self.tools]
+    
+    async def __aenter__(self):
+        """Async context manager entry."""
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        if self.transport:
+            await self.transport.__aexit__(exc_type, exc_val, exc_tb)
+        if hasattr(self, '_session_context') and self._session_context:
+            await self._session_context.__aexit__(exc_type, exc_val, exc_tb)

praisonaiagents/mcp/mcp_sse.py

@@ -44,13 +44,30 @@ class SSEMCPTool:
         # Create a signature based on input schema
         params = []
         if input_schema and 'properties' in input_schema:
-            for param_name in input_schema['properties']:
+            for param_name, prop_schema in input_schema['properties'].items():
+                # Determine type annotation based on schema
+                prop_type = prop_schema.get('type', 'string') if isinstance(prop_schema, dict) else 'string'
+                if prop_type == 'string':
+                    annotation = str
+                elif prop_type == 'integer':
+                    annotation = int
+                elif prop_type == 'number':
+                    annotation = float
+                elif prop_type == 'boolean':
+                    annotation = bool
+                elif prop_type == 'array':
+                    annotation = list
+                elif prop_type == 'object':
+                    annotation = dict
+                else:
+                    annotation = str  # Default to string for SSE
+                
                 params.append(
                     inspect.Parameter(
                         name=param_name,
                         kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
                         default=inspect.Parameter.empty if param_name in input_schema.get('required', []) else None,
-                        annotation=str  # Default to string
+                        annotation=annotation
                     )
                 )
         

praisonaiagents/process/process.py

@@ -16,6 +16,7 @@ class LoopItems(BaseModel):
 
 class Process:
     DEFAULT_RETRY_LIMIT = 3  # Predefined retry limit in a common place
+    VALIDATION_FAILURE_DECISIONS = ["invalid", "retry", "failed", "error", "unsuccessful", "fail", "errors", "reject", "rejected", "incomplete"]  # Decision strings that trigger validation feedback
 
     def __init__(self, tasks: Dict[str, Task], agents: List[Agent], manager_llm: Optional[str] = None, verbose: bool = False, max_iter: int = 10):
         logging.debug(f"=== Initializing Process ===")
@@ -33,12 +34,38 @@ class Process:
         self.task_retry_counter: Dict[str, int] = {} # Initialize retry counter
         self.workflow_finished = False # ADDED: Workflow finished flag
 
+    def _create_loop_subtasks(self, loop_task: Task):
+        """Create subtasks for a loop task from input file."""
+        logging.warning(f"_create_loop_subtasks called for {loop_task.name} but method not fully implemented")
+        # TODO: Implement loop subtask creation from input file
+        # This should read loop_task.input_file and create subtasks
+        pass
+
     def _build_task_context(self, current_task: Task) -> str:
         """Build context for a task based on its retain_full_context setting"""
-        if not (current_task.previous_tasks or current_task.context):
-            return ""
+        # Check if we have validation feedback to include
+        if current_task.validation_feedback:
+            feedback = current_task.validation_feedback
+            context = f"\nPrevious attempt failed validation with reason: {feedback['validation_response']}"
+            if feedback.get('validated_task'):
+                context += f"\nValidated task: {feedback['validated_task']}"
+            if feedback.get('validation_details'):
+                context += f"\nValidation feedback: {feedback['validation_details']}"
+            if feedback.get('rejected_output'):
+                context += f"\nRejected output: {feedback['rejected_output']}"
+            context += "\nPlease try again with a different approach based on this feedback.\n"
+            # Clear the feedback after including it to prevent it from persisting
+            current_task.validation_feedback = None
             
-        context = "\nInput data from previous tasks:"
+            # If we have validation feedback but no previous tasks context, return just the feedback
+            if not (current_task.previous_tasks or current_task.context):
+                return context
+            # Otherwise, append the regular context
+            context += "\nInput data from previous tasks:"
+        elif not (current_task.previous_tasks or current_task.context):
+            return ""
+        else:
+            context = "\nInput data from previous tasks:"
         
         if current_task.retain_full_context:
             # Original behavior: include all previous tasks
@@ -496,6 +523,35 @@ Subtask: {st.name}
                             next_task = next((t for t in self.tasks.values() if t.name == task_value), None)
                             if next_task:
                                 next_task.status = "not started"  # Reset status to allow execution
+                                
+                                # Capture validation feedback for retry scenarios
+                                if decision_str in Process.VALIDATION_FAILURE_DECISIONS:
+                                    if current_task and current_task.result:
+                                        # Get the rejected output from the task that was validated
+                                        validated_task = None
+                                        # Find the task that produced the output being validated
+                                        if current_task.previous_tasks:
+                                            # For validation tasks, typically validate the most recent previous task
+                                            prev_task_name = current_task.previous_tasks[-1]
+                                            validated_task = next((t for t in self.tasks.values() if t.name == prev_task_name), None)
+                                        elif current_task.context:
+                                            # If no previous_tasks, check context for the validated task
+                                            # Use the most recent task with a result from context
+                                            for ctx_task in reversed(current_task.context):
+                                                if ctx_task.result and ctx_task.name != current_task.name:
+                                                    validated_task = ctx_task
+                                                    break
+                                        
+                                        feedback = {
+                                            'validation_response': decision_str,
+                                            'validation_details': current_task.result.raw,
+                                            'rejected_output': validated_task.result.raw if validated_task and validated_task.result else None,
+                                            'validator_task': current_task.name,
+                                            'validated_task': validated_task.name if validated_task else None
+                                        }
+                                        next_task.validation_feedback = feedback
+                                        logging.debug(f"Added validation feedback to {next_task.name}: {feedback['validation_response']} (validated task: {feedback.get('validated_task', 'None')})")
+                                
                                 logging.debug(f"Routing to {next_task.name} based on decision: {decision_str}")
                                 # Don't mark workflow as finished when following condition path
                                 self.workflow_finished = False
@@ -1098,6 +1154,35 @@ Subtask: {st.name}
                             next_task = next((t for t in self.tasks.values() if t.name == task_value), None)
                             if next_task:
                                 next_task.status = "not started"  # Reset status to allow execution
+                                
+                                # Capture validation feedback for retry scenarios
+                                if decision_str in Process.VALIDATION_FAILURE_DECISIONS:
+                                    if current_task and current_task.result:
+                                        # Get the rejected output from the task that was validated
+                                        validated_task = None
+                                        # Find the task that produced the output being validated
+                                        if current_task.previous_tasks:
+                                            # For validation tasks, typically validate the most recent previous task
+                                            prev_task_name = current_task.previous_tasks[-1]
+                                            validated_task = next((t for t in self.tasks.values() if t.name == prev_task_name), None)
+                                        elif current_task.context:
+                                            # If no previous_tasks, check context for the validated task
+                                            # Use the most recent task with a result from context
+                                            for ctx_task in reversed(current_task.context):
+                                                if ctx_task.result and ctx_task.name != current_task.name:
+                                                    validated_task = ctx_task
+                                                    break
+                                        
+                                        feedback = {
+                                            'validation_response': decision_str,
+                                            'validation_details': current_task.result.raw,
+                                            'rejected_output': validated_task.result.raw if validated_task and validated_task.result else None,
+                                            'validator_task': current_task.name,
+                                            'validated_task': validated_task.name if validated_task else None
+                                        }
+                                        next_task.validation_feedback = feedback
+                                        logging.debug(f"Added validation feedback to {next_task.name}: {feedback['validation_response']} (validated task: {feedback.get('validated_task', 'None')})")
+                                
                                 logging.debug(f"Routing to {next_task.name} based on decision: {decision_str}")
                                 # Don't mark workflow as finished when following condition path
                                 self.workflow_finished = False

praisonaiagents/task/task.py

@@ -88,6 +88,7 @@ class Task:
         self.max_retries = max_retries
         self.retry_count = retry_count
         self._guardrail_fn = None
+        self.validation_feedback = None  # Store validation failure feedback for retry attempts
 
         # Set logger level based on config verbose level
         verbose = self.config.get("verbose", 0)

{praisonaiagents-0.0.124.dist-info → praisonaiagents-0.0.125.dist-info}/METADATA

@@ -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.dist-info → praisonaiagents-0.0.125.dist-info}/RECORD

@@ -1,6 +1,6 @@
-praisonaiagents/__init__.py,sha256=TezvgadS1p5FGnIRAUVOB_6Jzb3Of7ZtzjtyeCqRsmM,3017
+praisonaiagents/__init__.py,sha256=7DZJjhHa1_OeP0aiR5_iXINXYiug_gtbOuh_ylad6Uc,3847
 praisonaiagents/approval.py,sha256=UJ4OhfihpFGR5CAaMphqpSvqdZCHi5w2MGw1MByZ1FQ,9813
-praisonaiagents/main.py,sha256=bamnEu5PaekloGi52VqAFclm-HzjEVeKtWF0Zpdmfzs,15479
+praisonaiagents/main.py,sha256=7HEFVNmxMzRjVpbe52aYvQMZA013mA3YosrixM_Ua8Q,14975
 praisonaiagents/session.py,sha256=d-CZPYikOHb0q-H9f_IWKJsypnQfz1YKeLLkyxs6oDo,15532
 praisonaiagents/agent/__init__.py,sha256=IhIDtAkfJ99cxbttwou52coih_AejS2-jpazsX6LbDY,350
 praisonaiagents/agent/agent.py,sha256=9JB46swjvrPSm7pQnsawGd2mV50qA-tx3Vv05_OoJeU,119579
@@ -14,20 +14,21 @@ praisonaiagents/guardrails/guardrail_result.py,sha256=2K1WIYRyT_s1H6vBGa-7HEHzXC
 praisonaiagents/guardrails/llm_guardrail.py,sha256=MTTqmYDdZX-18QN9T17T5P_6H2qnV8GVgymJufW1WuM,3277
 praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9bge0Ujuto,246
 praisonaiagents/knowledge/chunking.py,sha256=G6wyHa7_8V0_7VpnrrUXbEmUmptlT16ISJYaxmkSgmU,7678
-praisonaiagents/knowledge/knowledge.py,sha256=OKPar-XGyAp1ndmbOOdCgqFnTCqpOThYVSIZRxZyP58,15683
-praisonaiagents/llm/__init__.py,sha256=2rCx-Vfgg881XhVnOSDIt8mDab3Nj_BkHwDP4Bbbudc,1596
-praisonaiagents/llm/llm.py,sha256=9AQdZzd12d_DY6A_jPPfFSHhiEYaqZidVkguoY8j8Es,108522
+praisonaiagents/knowledge/knowledge.py,sha256=-di_h9HxXQfAhTMMerhK16tfw8DtUndp44TGkBOzkZs,15539
+praisonaiagents/llm/__init__.py,sha256=DtFSBjsVQj7AOTM0x5Q0bZnrbxb-t2ljom5Aid5xJEs,1547
+praisonaiagents/llm/llm.py,sha256=_zOKvdKkwG6Eojf0tyBlS1txSaj3H0nCAeUtm4ohHoI,110234
 praisonaiagents/llm/model_capabilities.py,sha256=poxOxATUOi9XPTx3v6BPnXvSfikWSA9NciWQVuPU7Zg,2586
 praisonaiagents/llm/openai_client.py,sha256=0JvjCDHoH8I8kIt5vvObARkGdVaPWdTIv_FoEQ5EQPA,48973
 praisonaiagents/mcp/__init__.py,sha256=ibbqe3_7XB7VrIcUcetkZiUZS1fTVvyMy_AqCSFG8qc,240
-praisonaiagents/mcp/mcp.py,sha256=-fFx4MHffnN2woLnnV7Pzx3-1SFkn2j8Gp5F5ZIwKJ0,19698
-praisonaiagents/mcp/mcp_sse.py,sha256=z8TMFhW9xuLQ7QnpOa3n1-nSHt0-Bf27qso0u4qxYSY,8357
+praisonaiagents/mcp/mcp.py,sha256=T0G0rQotHxk9qTnG1tjQLr4c0BUSLnEqz9sIMx4F954,21598
+praisonaiagents/mcp/mcp_http_stream.py,sha256=Yh-69eIlLQS_M0bd__y7NzSjOqqX6R8Ed4eJQw6xXgg,18314
+praisonaiagents/mcp/mcp_sse.py,sha256=KO10tAgZ5vSKeRhkJIZcdJ0ZmhRybS39i1KybWt4D7M,9128
 praisonaiagents/memory/__init__.py,sha256=aEFdhgtTqDdMhc_JCWM-f4XI9cZIj7Wz5g_MUa-0amg,397
 praisonaiagents/memory/memory.py,sha256=D5BmQTktv6VOJ49yW2m1MjjCJ5UDSX1Qo46_443ymKo,44276
 praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
-praisonaiagents/process/process.py,sha256=NTc9rbelIdEA-S1Nwd79OVeKA7mmoZWXhD5r8S91LNs,66624
+praisonaiagents/process/process.py,sha256=qar8gljiU1DrpIKvKI1jZqQ8g2g_BGCG01l-FtYwj-U,73449
 praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
-praisonaiagents/task/task.py,sha256=imqJ8wzZzVyUSym2EyF2tC-vAsV1UdfI_P3YM5mqAiw,20786
+praisonaiagents/task/task.py,sha256=vehRhEpTTBWTv-qxHMhJwcshdyR821TYQAaODDpaOL4,20882
 praisonaiagents/telemetry/__init__.py,sha256=5iAOrj_N_cKMmh2ltWGYs3PfOYt_jcwUoElW8fTAIsc,3062
 praisonaiagents/telemetry/integration.py,sha256=8h8TDlPFTbsBmU5rIYNOibJbwEEEWmzS1ENE9uPTvvg,8696
 praisonaiagents/telemetry/telemetry.py,sha256=SAEK5lrHn-Rb3nk_Yx1sjAdRxqT63ycyNRv3ZGh9Rck,11812
@@ -54,7 +55,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.124.dist-info/METADATA,sha256=_yFtjXGrQjKln7yCjLdflt8r0CGBVCpy-8EBFDzeMJQ,1669
-praisonaiagents-0.0.124.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-praisonaiagents-0.0.124.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.124.dist-info/RECORD,,
+praisonaiagents-0.0.125.dist-info/METADATA,sha256=h5XqjtcCkP0-ls4vCnQyOMTxwmAhCJKTw3dvKztChHs,1699
+praisonaiagents-0.0.125.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+praisonaiagents-0.0.125.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.125.dist-info/RECORD,,