praisonaiagents 0.0.80__py3-none-any.whl → 0.0.82__py3-none-any.whl

praisonaiagents/agent/agent.py

@@ -23,9 +23,9 @@ import uuid
 from dataclasses import dataclass
 
 # Global variables for API server
-_server_started = False
-_registered_agents = {}
-_shared_app = None
+_server_started = {}  # Dict of port -> started boolean
+_registered_agents = {}  # Dict of port -> Dict of path -> agent_id
+_shared_apps = {}  # Dict of port -> FastAPI app
 
 # Don't import FastAPI dependencies here - use lazy loading instead
 
@@ -1095,6 +1095,10 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
         start_time = time.time()
         reasoning_steps = reasoning_steps or self.reasoning_steps
         try:
+            # Default to self.tools if tools argument is None
+            if tools is None:
+                tools = self.tools
+
             # Search for existing knowledge if any knowledge is provided
             if self.knowledge:
                 search_results = self.knowledge.search(prompt, agent_id=self.agent_id)
@@ -1408,181 +1412,329 @@ Your Goal: {self.goal}
             logging.error(f"Error in execute_tool_async: {str(e)}", exc_info=True)
             return {"error": f"Error in execute_tool_async: {str(e)}"}
 
-    def launch(self, path: str = '/', port: int = 8000, host: str = '0.0.0.0', debug: bool = False):
+    def launch(self, path: str = '/', port: int = 8000, host: str = '0.0.0.0', debug: bool = False, protocol: str = "http"):
         """
-        Launch the agent as an HTTP API endpoint.
+        Launch the agent as an HTTP API endpoint or an MCP server.
         
         Args:
-            path: API endpoint path (default: '/')
+            path: API endpoint path (default: '/') for HTTP, or base path for MCP.
             port: Server port (default: 8000)
             host: Server host (default: '0.0.0.0')
             debug: Enable debug mode for uvicorn (default: False)
+            protocol: "http" to launch as FastAPI, "mcp" to launch as MCP server.
             
         Returns:
             None
         """
-        global _server_started, _registered_agents, _shared_app
-        
-        # Try to import FastAPI dependencies - lazy loading
-        try:
-            import uvicorn
-            from fastapi import FastAPI, HTTPException, Request
-            from fastapi.responses import JSONResponse
-            from pydantic import BaseModel
-            import threading
-            import time
+        if protocol == "http":
+            global _server_started, _registered_agents, _shared_apps
             
-            # Define the request model here since we need pydantic
-            class AgentQuery(BaseModel):
-                query: str
+            # Try to import FastAPI dependencies - lazy loading
+            try:
+                import uvicorn
+                from fastapi import FastAPI, HTTPException, Request
+                from fastapi.responses import JSONResponse
+                from pydantic import BaseModel
+                import threading
+                import time
                 
-        except ImportError as e:
-            # Check which specific module is missing
-            missing_module = str(e).split("No module named '")[-1].rstrip("'")
-            display_error(f"Missing dependency: {missing_module}. Required for launch() method.")
-            logging.error(f"Missing dependency: {missing_module}. Required for launch() method.")
-            print(f"\nTo add API capabilities, install the required dependencies:")
-            print(f"pip install {missing_module}")
-            print("\nOr install all API dependencies with:")
-            print("pip install 'praisonaiagents[api]'")
-            return None
-            
-        # Initialize shared FastAPI app if not already created
-        if _shared_app is None:
-            _shared_app = FastAPI(
-                title="PraisonAI Agents API",
-                description="API for interacting with PraisonAI Agents"
-            )
+                # Define the request model here since we need pydantic
+                class AgentQuery(BaseModel):
+                    query: str
+                    
+            except ImportError as e:
+                # Check which specific module is missing
+                missing_module = str(e).split("No module named '")[-1].rstrip("'")
+                display_error(f"Missing dependency: {missing_module}. Required for launch() method with HTTP mode.")
+                logging.error(f"Missing dependency: {missing_module}. Required for launch() method with HTTP mode.")
+                print(f"\nTo add API capabilities, install the required dependencies:")
+                print(f"pip install {missing_module}")
+                print("\nOr install all API dependencies with:")
+                print("pip install 'praisonaiagents[api]'")
+                return None
+                
+            # Initialize port-specific collections if needed
+            if port not in _registered_agents:
+                _registered_agents[port] = {}
+                
+            # Initialize shared FastAPI app if not already created for this port
+            if _shared_apps.get(port) is None:
+                _shared_apps[port] = FastAPI(
+                    title=f"PraisonAI Agents API (Port {port})",
+                    description="API for interacting with PraisonAI Agents"
+                )
+                
+                # Add a root endpoint with a welcome message
+                @_shared_apps[port].get("/")
+                async def root():
+                    return {
+                        "message": f"Welcome to PraisonAI Agents API on port {port}. See /docs for usage.",
+                        "endpoints": list(_registered_agents[port].keys())
+                    }
+                
+                # Add healthcheck endpoint
+                @_shared_apps[port].get("/health")
+                async def healthcheck():
+                    return {
+                        "status": "ok", 
+                        "endpoints": list(_registered_agents[port].keys())
+                    }
             
-            # Add a root endpoint with a welcome message
-            @_shared_app.get("/")
-            async def root():
-                return {"message": "Welcome to PraisonAI Agents API. See /docs for usage."}
+            # Normalize path to ensure it starts with /
+            if not path.startswith('/'):
+                path = f'/{path}'
+                
+            # Check if path is already registered for this port
+            if path in _registered_agents[port]:
+                logging.warning(f"Path '{path}' is already registered on port {port}. Please use a different path.")
+                print(f"⚠️ Warning: Path '{path}' is already registered on port {port}.")
+                # Use a modified path to avoid conflicts
+                original_path = path
+                path = f"{path}_{self.agent_id[:6]}"
+                logging.warning(f"Using '{path}' instead of '{original_path}'")
+                print(f"🔄 Using '{path}' instead")
             
-            # Add healthcheck endpoint
-            @_shared_app.get("/health")
-            async def healthcheck():
-                return {"status": "ok", "agents": list(_registered_agents.keys())}
-        
-        # Normalize path to ensure it starts with /
-        if not path.startswith('/'):
-            path = f'/{path}'
+            # Register the agent to this path
+            _registered_agents[port][path] = self.agent_id
             
-        # Check if path is already registered by another agent
-        if path in _registered_agents and _registered_agents[path] != self.agent_id:
-            existing_agent = _registered_agents[path]
-            logging.warning(f"Path '{path}' is already registered by another agent. Please use a different path.")
-            print(f"⚠️ Warning: Path '{path}' is already registered by another agent.")
-            # Use a modified path to avoid conflicts
-            original_path = path
-            path = f"{path}_{self.agent_id[:6]}"
-            logging.warning(f"Using '{path}' instead of '{original_path}'")
-            print(f"🔄 Using '{path}' instead")
-        
-        # Register the agent to this path
-        _registered_agents[path] = self.agent_id
-        
-        # Define the endpoint handler
-        @_shared_app.post(path)
-        async def handle_agent_query(request: Request, query_data: Optional[AgentQuery] = None):
-            # Handle both direct JSON with query field and form data
-            if query_data is None:
+            # Define the endpoint handler
+            @_shared_apps[port].post(path)
+            async def handle_agent_query(request: Request, query_data: Optional[AgentQuery] = None):
+                # Handle both direct JSON with query field and form data
+                if query_data is None:
+                    try:
+                        request_data = await request.json()
+                        if "query" not in request_data:
+                            raise HTTPException(status_code=400, detail="Missing 'query' field in request")
+                        query = request_data["query"]
+                    except:
+                        # Fallback to form data or query params
+                        form_data = await request.form()
+                        if "query" in form_data:
+                            query = form_data["query"]
+                        else:
+                            raise HTTPException(status_code=400, detail="Missing 'query' field in request")
+                else:
+                    query = query_data.query
+                    
                 try:
-                    request_data = await request.json()
-                    if "query" not in request_data:
-                        raise HTTPException(status_code=400, detail="Missing 'query' field in request")
-                    query = request_data["query"]
-                except:
-                    # Fallback to form data or query params
-                    form_data = await request.form()
-                    if "query" in form_data:
-                        query = form_data["query"]
+                    # Use async version if available, otherwise use sync version
+                    if asyncio.iscoroutinefunction(self.chat):
+                        response = await self.achat(query)
                     else:
-                        raise HTTPException(status_code=400, detail="Missing 'query' field in request")
-            else:
-                query = query_data.query
+                        # Run sync function in a thread to avoid blocking
+                        loop = asyncio.get_event_loop()
+                        response = await loop.run_in_executor(None, lambda p=query: self.chat(p))
+                    
+                    return {"response": response}
+                except Exception as e:
+                    logging.error(f"Error processing query: {str(e)}", exc_info=True)
+                    return JSONResponse(
+                        status_code=500,
+                        content={"error": f"Error processing query: {str(e)}"}
+                    )
+            
+            print(f"🚀 Agent '{self.name}' available at http://{host}:{port}")
+            
+            # Start the server if it's not already running for this port
+            if not _server_started.get(port, False):
+                # Mark the server as started first to prevent duplicate starts
+                _server_started[port] = True
                 
-            try:
-                # Use async version if available, otherwise use sync version
-                if asyncio.iscoroutinefunction(self.chat):
-                    response = await self.achat(query)
-                else:
-                    # Run sync function in a thread to avoid blocking
-                    loop = asyncio.get_event_loop()
-                    response = await loop.run_in_executor(None, lambda: self.chat(query))
+                # Start the server in a separate thread
+                def run_server():
+                    try:
+                        print(f"✅ FastAPI server started at http://{host}:{port}")
+                        print(f"📚 API documentation available at http://{host}:{port}/docs")
+                        print(f"🔌 Available endpoints: {', '.join(list(_registered_agents[port].keys()))}")
+                        uvicorn.run(_shared_apps[port], host=host, port=port, log_level="debug" if debug else "info")
+                    except Exception as e:
+                        logging.error(f"Error starting server: {str(e)}", exc_info=True)
+                        print(f"❌ Error starting server: {str(e)}")
                 
-                return {"response": response}
-            except Exception as e:
-                logging.error(f"Error processing query: {str(e)}", exc_info=True)
-                return JSONResponse(
-                    status_code=500,
-                    content={"error": f"Error processing query: {str(e)}"}
-                )
-        
-        print(f"🚀 Agent '{self.name}' available at http://{host}:{port}{path}")
-        
-        # Start the server if it's not already running
-        if not _server_started:
-            _server_started = True
+                # Run server in a background thread
+                server_thread = threading.Thread(target=run_server, daemon=True)
+                server_thread.start()
+                
+                # Wait for a moment to allow the server to start and register endpoints
+                time.sleep(0.5)
+            else:
+                # If server is already running, wait a moment to make sure the endpoint is registered
+                time.sleep(0.1)
+                print(f"🔌 Available endpoints on port {port}: {', '.join(list(_registered_agents[port].keys()))}")
+            
+            # Get the stack frame to check if this is the last launch() call in the script
+            import inspect
+            stack = inspect.stack()
             
-            # Start the server in a separate thread
-            def run_server():
+            # If this is called from a Python script (not interactive), try to detect if it's the last launch call
+            if len(stack) > 1 and stack[1].filename.endswith('.py'):
+                caller_frame = stack[1]
+                caller_line = caller_frame.lineno
+                
                 try:
-                    print(f"✅ FastAPI server started at http://{host}:{port}")
-                    print(f"📚 API documentation available at http://{host}:{port}/docs")
-                    print(f"🔌 Available endpoints: {', '.join(list(_registered_agents.keys()))}")
-                    uvicorn.run(_shared_app, host=host, port=port, log_level="debug" if debug else "info")
+                    # Read the file to check if there are more launch calls after this one
+                    with open(caller_frame.filename, 'r') as f:
+                        lines = f.readlines()
+                    
+                    # Check if there are more launch() calls after the current line
+                    has_more_launches = False
+                    for line_content in lines[caller_line:]: # renamed line to line_content
+                        if '.launch(' in line_content and not line_content.strip().startswith('#'):
+                            has_more_launches = True
+                            break
+                    
+                    # If this is the last launch call, block the main thread
+                    if not has_more_launches:
+                        try:
+                            print("\nAll agents registered for HTTP mode. Press Ctrl+C to stop the servers.")
+                            while True:
+                                time.sleep(1)
+                        except KeyboardInterrupt:
+                            print("\nServers stopped")
                 except Exception as e:
-                    logging.error(f"Error starting server: {str(e)}", exc_info=True)
-                    print(f"❌ Error starting server: {str(e)}")
-            
-            # Run server in a background thread
-            server_thread = threading.Thread(target=run_server, daemon=True)
-            server_thread.start()
-            
-            # Wait for a moment to allow the server to start and register endpoints
-            time.sleep(0.5)
-        else:
-            # If server is already running, wait a moment to make sure the endpoint is registered
-            time.sleep(0.1)
-            print(f"🔌 Available endpoints: {', '.join(list(_registered_agents.keys()))}")
-        
-        # Get the stack frame to check if this is the last launch() call in the script
-        import inspect
-        stack = inspect.stack()
-        
-        # If this is called from a Python script (not interactive), try to detect if it's the last launch call
-        if len(stack) > 1 and stack[1].filename.endswith('.py'):
-            caller_frame = stack[1]
-            caller_line = caller_frame.lineno
+                    # If something goes wrong with detection, block anyway to be safe
+                    logging.error(f"Error in launch detection: {e}")
+                    try:
+                        print("\nKeeping HTTP servers alive. Press Ctrl+C to stop.")
+                        while True:
+                            time.sleep(1)
+                    except KeyboardInterrupt:
+                        print("\nServers stopped")
+            return None
             
+        elif protocol == "mcp":
             try:
-                # Read the file to check if there are more launch calls after this one
-                with open(caller_frame.filename, 'r') as f:
-                    lines = f.readlines()
+                import uvicorn
+                from mcp.server.fastmcp import FastMCP
+                from mcp.server.sse import SseServerTransport
+                from starlette.applications import Starlette
+                from starlette.requests import Request
+                from starlette.routing import Mount, Route
+                from mcp.server import Server as MCPServer # Alias to avoid conflict
+                import threading
+                import time
+                import inspect
+                import asyncio # Ensure asyncio is imported
+                # logging is already imported at the module level
                 
-                # Check if there are more launch() calls after the current line
-                has_more_launches = False
-                for line in lines[caller_line:]:
-                    if '.launch(' in line and not line.strip().startswith('#'):
-                        has_more_launches = True
-                        break
-                
-                # If this is the last launch call, block the main thread
-                if not has_more_launches:
+            except ImportError as e:
+                missing_module = str(e).split("No module named '")[-1].rstrip("'")
+                display_error(f"Missing dependency: {missing_module}. Required for launch() method with MCP mode.")
+                logging.error(f"Missing dependency: {missing_module}. Required for launch() method with MCP mode.")
+                print(f"\nTo add MCP capabilities, install the required dependencies:")
+                print(f"pip install {missing_module} mcp praison-mcp starlette uvicorn") # Added mcp, praison-mcp, starlette, uvicorn
+                print("\nOr install all MCP dependencies with relevant packages.")
+                return None
+
+            mcp_server_instance_name = f"{self.name}_mcp_server" if self.name else "agent_mcp_server"
+            mcp = FastMCP(mcp_server_instance_name)
+
+            # Determine the MCP tool name based on self.name
+            actual_mcp_tool_name = f"execute_{self.name.lower().replace(' ', '_').replace('-', '_')}_task" if self.name \
+                else "execute_task"
+
+            @mcp.tool(name=actual_mcp_tool_name)
+            async def execute_agent_task(prompt: str) -> str:
+                """Executes the agent's primary task with the given prompt."""
+                logging.info(f"MCP tool '{actual_mcp_tool_name}' called with prompt: {prompt}")
+                try:
+                    # Ensure self.achat is used as it's the async version and pass its tools
+                    if hasattr(self, 'achat') and asyncio.iscoroutinefunction(self.achat):
+                        response = await self.achat(prompt, tools=self.tools)
+                    elif hasattr(self, 'chat'): # Fallback for synchronous chat
+                        loop = asyncio.get_event_loop()
+                        response = await loop.run_in_executor(None, lambda p=prompt: self.chat(p, tools=self.tools))
+                    else:
+                        logging.error(f"Agent {self.name} has no suitable chat or achat method for MCP tool.")
+                        return f"Error: Agent {self.name} misconfigured for MCP."
+                    return response if response is not None else "Agent returned no response."
+                except Exception as e:
+                    logging.error(f"Error in MCP tool '{actual_mcp_tool_name}': {e}", exc_info=True)
+                    return f"Error executing task: {str(e)}"
+
+            # Normalize base_path for MCP routes
+            base_path = path.rstrip('/')
+            sse_path = f"{base_path}/sse"
+            messages_path_prefix = f"{base_path}/messages" # Prefix for message posting
+            
+            # Ensure messages_path ends with a slash for Mount
+            if not messages_path_prefix.endswith('/'):
+                messages_path_prefix += '/'
+
+
+            sse_transport = SseServerTransport(messages_path_prefix) # Pass the full prefix
+
+            async def handle_sse_connection(request: Request) -> None:
+                logging.debug(f"SSE connection request received from {request.client} for path {request.url.path}")
+                async with sse_transport.connect_sse(
+                        request.scope,
+                        request.receive,
+                        request._send,  # noqa: SLF001
+                ) as (read_stream, write_stream):
+                    await mcp._mcp_server.run( # Use the underlying server from FastMCP
+                        read_stream,
+                        write_stream,
+                        mcp._mcp_server.create_initialization_options(),
+                    )
+            
+            starlette_app = Starlette(
+                debug=debug,
+                routes=[
+                    Route(sse_path, endpoint=handle_sse_connection),
+                    Mount(messages_path_prefix, app=sse_transport.handle_post_message),
+                ],
+            )
+
+            print(f"🚀 Agent '{self.name}' MCP server starting on http://{host}:{port}")
+            print(f"📡 MCP SSE endpoint available at {sse_path}")
+            print(f"📢 MCP messages post to {messages_path_prefix}")
+            # Instead of trying to extract tool names, hardcode the known tool name
+            tool_names = [actual_mcp_tool_name]  # Use the determined dynamic tool name
+            print(f"🛠️ Available MCP tools: {', '.join(tool_names)}")
+
+            # Uvicorn server running logic (similar to HTTP mode but standalone for MCP)
+            def run_mcp_server():
+                try:
+                    uvicorn.run(starlette_app, host=host, port=port, log_level="debug" if debug else "info")
+                except Exception as e:
+                    logging.error(f"Error starting MCP server: {str(e)}", exc_info=True)
+                    print(f"❌ Error starting MCP server: {str(e)}")
+
+            server_thread = threading.Thread(target=run_mcp_server, daemon=True)
+            server_thread.start()
+            time.sleep(0.5) # Allow server to start
+
+            # Blocking logic for MCP mode
+            import inspect # Already imported but good for clarity
+            stack = inspect.stack()
+            if len(stack) > 1 and stack[1].filename.endswith('.py'):
+                caller_frame = stack[1]
+                caller_line = caller_frame.lineno
+                try:
+                    with open(caller_frame.filename, 'r') as f:
+                        lines = f.readlines()
+                    has_more_launches = False
+                    for line_content in lines[caller_line:]: # renamed line to line_content
+                        if '.launch(' in line_content and not line_content.strip().startswith('#'):
+                            has_more_launches = True
+                            break
+                    if not has_more_launches:
+                        try:
+                            print("\nAgent MCP server running. Press Ctrl+C to stop.")
+                            while True:
+                                time.sleep(1)
+                        except KeyboardInterrupt:
+                            print("\nMCP Server stopped")
+                except Exception as e:
+                    logging.error(f"Error in MCP launch detection: {e}")
                     try:
-                        print("\nAll agents registered. Press Ctrl+C to stop the server.")
+                        print("\nKeeping MCP server alive. Press Ctrl+C to stop.")
                         while True:
                             time.sleep(1)
                     except KeyboardInterrupt:
-                        print("\nServer stopped")
-            except Exception as e:
-                # If something goes wrong with detection, block anyway to be safe
-                logging.error(f"Error in launch detection: {e}")
-                try:
-                    while True:
-                        time.sleep(1)
-                except KeyboardInterrupt:
-                    print("\nServer stopped")
-        
-        return None 
+                        print("\nMCP Server stopped")
+            return None
+        else:
+            display_error(f"Invalid protocol: {protocol}. Choose 'http' or 'mcp'.")
+            return None 

praisonaiagents/agents/agents.py

@@ -50,7 +50,7 @@ def process_video(video_path: str, seconds_per_frame=2):
     return base64_frames
 
 class PraisonAIAgents:
-    def __init__(self, agents, tasks=None, verbose=0, completion_checker=None, max_retries=5, process="sequential", manager_llm=None, memory=False, memory_config=None, embedder=None, user_id=None, max_iter=10, stream=True):
+    def __init__(self, agents, tasks=None, verbose=0, completion_checker=None, max_retries=5, process="sequential", manager_llm=None, memory=False, memory_config=None, embedder=None, user_id=None, max_iter=10, stream=True, name: Optional[str] = None):
         # Add check at the start if memory is requested
         if memory:
             try:
@@ -83,6 +83,7 @@ class PraisonAIAgents:
         self.max_retries = max_retries
         self.process = process
         self.stream = stream
+        self.name = name  # Store the name for the Agents collection
         
         # Check for manager_llm in environment variable if not provided
         self.manager_llm = manager_llm or os.getenv('OPENAI_MODEL_NAME', 'gpt-4o')
@@ -885,228 +886,381 @@ Context:
         """Clear all state values"""
         self._state.clear()
         
-    def launch(self, path: str = '/agents', port: int = 8000, host: str = '0.0.0.0', debug: bool = False):
+    def launch(self, path: str = '/agents', port: int = 8000, host: str = '0.0.0.0', debug: bool = False, protocol: str = "http"):
         """
-        Launch all agents as a single API endpoint. The endpoint accepts a query and processes it through
-        all agents in sequence, with the output of each agent feeding into the next.
+        Launch all agents as a single API endpoint (HTTP) or an MCP server. 
+        In HTTP mode, the endpoint accepts a query and processes it through all agents in sequence.
+        In MCP mode, an MCP server is started, exposing a tool to run the agent workflow.
         
         Args:
-            path: API endpoint path (default: '/agents')
+            path: API endpoint path (default: '/agents') for HTTP, or base path for MCP.
             port: Server port (default: 8000)
             host: Server host (default: '0.0.0.0')
             debug: Enable debug mode for uvicorn (default: False)
+            protocol: "http" to launch as FastAPI, "mcp" to launch as MCP server.
             
         Returns:
             None
         """
-        global _agents_server_started, _agents_registered_endpoints, _agents_shared_apps
-        
-        if not self.agents:
-            logging.warning("No agents to launch. Add agents to the Agents instance first.")
-            return
+        if protocol == "http":
+            global _agents_server_started, _agents_registered_endpoints, _agents_shared_apps
             
-        # Try to import FastAPI dependencies - lazy loading
-        try:
-            import uvicorn
-            from fastapi import FastAPI, HTTPException, Request
-            from fastapi.responses import JSONResponse
-            from pydantic import BaseModel
-            import threading
-            import time
-            
-            # Define the request model here since we need pydantic
-            class AgentQuery(BaseModel):
-                query: str
+            if not self.agents:
+                logging.warning("No agents to launch for HTTP mode. Add agents to the Agents instance first.")
+                return
                 
-        except ImportError as e:
-            # Check which specific module is missing
-            missing_module = str(e).split("No module named '")[-1].rstrip("'")
-            display_error(f"Missing dependency: {missing_module}. Required for launch() method.")
-            logging.error(f"Missing dependency: {missing_module}. Required for launch() method.")
-            print(f"\nTo add API capabilities, install the required dependencies:")
-            print(f"pip install {missing_module}")
-            print("\nOr install all API dependencies with:")
-            print("pip install 'praisonaiagents[api]'")
-            return None
-        
-        # Initialize port-specific collections if needed
-        if port not in _agents_registered_endpoints:
-            _agents_registered_endpoints[port] = {}
+            # Try to import FastAPI dependencies - lazy loading
+            try:
+                import uvicorn
+                from fastapi import FastAPI, HTTPException, Request
+                from fastapi.responses import JSONResponse
+                from pydantic import BaseModel
+                import threading
+                import time
+                import asyncio # Ensure asyncio is imported for HTTP mode too
+                
+                # Define the request model here since we need pydantic
+                class AgentQuery(BaseModel):
+                    query: str
+                    
+            except ImportError as e:
+                # Check which specific module is missing
+                missing_module = str(e).split("No module named '")[-1].rstrip("'")
+                display_error(f"Missing dependency: {missing_module}. Required for launch() method with HTTP mode.")
+                logging.error(f"Missing dependency: {missing_module}. Required for launch() method with HTTP mode.")
+                print(f"\nTo add API capabilities, install the required dependencies:")
+                print(f"pip install {missing_module}")
+                print("\nOr install all API dependencies with:")
+                print("pip install 'praisonaiagents[api]'")
+                return None
             
-        # Initialize shared FastAPI app if not already created for this port
-        if _agents_shared_apps.get(port) is None:
-            _agents_shared_apps[port] = FastAPI(
-                title=f"PraisonAI Agents API (Port {port})",
-                description="API for interacting with multiple PraisonAI Agents"
-            )
+            # Initialize port-specific collections if needed
+            if port not in _agents_registered_endpoints:
+                _agents_registered_endpoints[port] = {}
+                
+            # Initialize shared FastAPI app if not already created for this port
+            if _agents_shared_apps.get(port) is None:
+                _agents_shared_apps[port] = FastAPI(
+                    title=f"PraisonAI Agents API (Port {port})",
+                    description="API for interacting with multiple PraisonAI Agents"
+                )
+                
+                # Add a root endpoint with a welcome message
+                @_agents_shared_apps[port].get("/")
+                async def root():
+                    return {
+                        "message": f"Welcome to PraisonAI Agents API on port {port}. See /docs for usage.",
+                        "endpoints": list(_agents_registered_endpoints[port].keys())
+                    }
+                
+                # Add healthcheck endpoint
+                @_agents_shared_apps[port].get("/health")
+                async def healthcheck():
+                    return {
+                        "status": "ok", 
+                        "endpoints": list(_agents_registered_endpoints[port].keys())
+                    }
             
-            # Add a root endpoint with a welcome message
-            @_agents_shared_apps[port].get("/")
-            async def root():
-                return {
-                    "message": f"Welcome to PraisonAI Agents API on port {port}. See /docs for usage.",
-                    "endpoints": list(_agents_registered_endpoints[port].keys())
-                }
+            # Normalize path to ensure it starts with /
+            if not path.startswith('/'):
+                path = f'/{path}'
+                
+            # Check if path is already registered for this port
+            if path in _agents_registered_endpoints[port]:
+                logging.warning(f"Path '{path}' is already registered on port {port}. Please use a different path.")
+                print(f"⚠️ Warning: Path '{path}' is already registered on port {port}.")
+                # Use a modified path to avoid conflicts
+                original_path = path
+                instance_id = str(uuid.uuid4())[:6]
+                path = f"{path}_{instance_id}"
+                logging.warning(f"Using '{path}' instead of '{original_path}'")
+                print(f"🔄 Using '{path}' instead")
             
-            # Add healthcheck endpoint
-            @_agents_shared_apps[port].get("/health")
-            async def healthcheck():
-                return {
-                    "status": "ok", 
-                    "endpoints": list(_agents_registered_endpoints[port].keys())
-                }
-        
-        # Normalize path to ensure it starts with /
-        if not path.startswith('/'):
-            path = f'/{path}'
+            # Generate a unique ID for this agent group's endpoint
+            endpoint_id = str(uuid.uuid4())
+            _agents_registered_endpoints[port][path] = endpoint_id
             
-        # Check if path is already registered for this port
-        if path in _agents_registered_endpoints[port]:
-            logging.warning(f"Path '{path}' is already registered on port {port}. Please use a different path.")
-            print(f"⚠️ Warning: Path '{path}' is already registered on port {port}.")
-            # Use a modified path to avoid conflicts
-            original_path = path
-            instance_id = str(uuid.uuid4())[:6]
-            path = f"{path}_{instance_id}"
-            logging.warning(f"Using '{path}' instead of '{original_path}'")
-            print(f"🔄 Using '{path}' instead")
-        
-        # Generate a unique ID for this agent group's endpoint
-        endpoint_id = str(uuid.uuid4())
-        _agents_registered_endpoints[port][path] = endpoint_id
-        
-        # Define the endpoint handler
-        @_agents_shared_apps[port].post(path)
-        async def handle_query(request: Request, query_data: Optional[AgentQuery] = None):
-            # Handle both direct JSON with query field and form data
-            if query_data is None:
+            # Define the endpoint handler
+            @_agents_shared_apps[port].post(path)
+            async def handle_query(request: Request, query_data: Optional[AgentQuery] = None):
+                # Handle both direct JSON with query field and form data
+                if query_data is None:
+                    try:
+                        request_data = await request.json()
+                        if "query" not in request_data:
+                            raise HTTPException(status_code=400, detail="Missing 'query' field in request")
+                        query = request_data["query"]
+                    except:
+                        # Fallback to form data or query params
+                        form_data = await request.form()
+                        if "query" in form_data:
+                            query = form_data["query"]
+                        else:
+                            raise HTTPException(status_code=400, detail="Missing 'query' field in request")
+                else:
+                    query = query_data.query
+                
                 try:
-                    request_data = await request.json()
-                    if "query" not in request_data:
-                        raise HTTPException(status_code=400, detail="Missing 'query' field in request")
-                    query = request_data["query"]
-                except:
-                    # Fallback to form data or query params
-                    form_data = await request.form()
-                    if "query" in form_data:
-                        query = form_data["query"]
-                    else:
-                        raise HTTPException(status_code=400, detail="Missing 'query' field in request")
+                    # Process the query sequentially through all agents
+                    current_input = query
+                    results = []
+                    
+                    for agent_instance in self.agents: # Corrected variable name to agent_instance
+                        try:
+                            # Use async version if available, otherwise use sync version
+                            if asyncio.iscoroutinefunction(agent_instance.chat):
+                                response = await agent_instance.achat(current_input)
+                            else:
+                                # Run sync function in a thread to avoid blocking
+                                loop = asyncio.get_event_loop()
+                                # Correctly pass current_input to the lambda for closure
+                                response = await loop.run_in_executor(None, lambda ci=current_input: agent_instance.chat(ci))
+                            
+                            # Store this agent's result
+                            results.append({
+                                "agent": agent_instance.name,
+                                "response": response
+                            })
+                            
+                            # Use this response as input to the next agent
+                            current_input = response
+                        except Exception as e:
+                            logging.error(f"Error with agent {agent_instance.name}: {str(e)}", exc_info=True)
+                            results.append({
+                                "agent": agent_instance.name,
+                                "error": str(e)
+                            })
+                            # Decide error handling: continue with original input, last good input, or stop? 
+                            # For now, let's continue with the last successful 'current_input' or original 'query' if first agent fails
+                            # This part might need refinement based on desired behavior.
+                            # If an agent fails, its 'response' might be None or an error string.
+                            # current_input will carry that forward. Or, we could choose to halt or use last good input.
+                    
+                    # Return all results and the final output
+                    return {
+                        "query": query,
+                        "results": results,
+                        "final_response": current_input
+                    }
+                except Exception as e:
+                    logging.error(f"Error processing query: {str(e)}", exc_info=True)
+                    return JSONResponse(
+                        status_code=500,
+                        content={"error": f"Error processing query: {str(e)}"}
+                    )
+            
+            print(f"🚀 Multi-Agent HTTP API available at http://{host}:{port}{path}")
+            agent_names = ", ".join([agent.name for agent in self.agents])
+            print(f"📊 Available agents for this endpoint ({len(self.agents)}): {agent_names}")
+            
+            # Start the server if it's not already running for this port
+            if not _agents_server_started.get(port, False):
+                # Mark the server as started first to prevent duplicate starts
+                _agents_server_started[port] = True
+                
+                # Start the server in a separate thread
+                def run_server():
+                    try:
+                        print(f"✅ FastAPI server started at http://{host}:{port}")
+                        print(f"📚 API documentation available at http://{host}:{port}/docs")
+                        print(f"🔌 Registered HTTP endpoints on port {port}: {', '.join(list(_agents_registered_endpoints[port].keys()))}")
+                        uvicorn.run(_agents_shared_apps[port], host=host, port=port, log_level="debug" if debug else "info")
+                    except Exception as e:
+                        logging.error(f"Error starting server: {str(e)}", exc_info=True)
+                        print(f"❌ Error starting server: {str(e)}")
+                
+                # Run server in a background thread
+                server_thread = threading.Thread(target=run_server, daemon=True)
+                server_thread.start()
+                
+                # Wait for a moment to allow the server to start and register endpoints
+                time.sleep(0.5)
             else:
-                query = query_data.query
+                # If server is already running, wait a moment to make sure the endpoint is registered
+                time.sleep(0.1)
+                print(f"🔌 Registered HTTP endpoints on port {port}: {', '.join(list(_agents_registered_endpoints[port].keys()))}")
+            
+            # Get the stack frame to check if this is the last launch() call in the script
+            import inspect
+            stack = inspect.stack()
             
+            # If this is called from a Python script (not interactive), try to detect if it's the last launch call
+            if len(stack) > 1 and stack[1].filename.endswith('.py'):
+                caller_frame = stack[1]
+                caller_line = caller_frame.lineno
+                
+                try:
+                    # Read the file to check if there are more launch calls after this one
+                    with open(caller_frame.filename, 'r') as f:
+                        lines = f.readlines()
+                    
+                    # Check if there are more launch() calls after the current line
+                    has_more_launches = False
+                    for line_content in lines[caller_line:]: # Renamed variable
+                        if '.launch(' in line_content and not line_content.strip().startswith('#'):
+                            has_more_launches = True
+                            break
+                    
+                    # If this is the last launch call, block the main thread
+                    if not has_more_launches:
+                        try:
+                            print("\nAll agent groups registered for HTTP mode. Press Ctrl+C to stop the servers.")
+                            while True:
+                                time.sleep(1)
+                        except KeyboardInterrupt:
+                            print("\nServers stopped")
+                except Exception as e:
+                    # If something goes wrong with detection, block anyway to be safe
+                    logging.error(f"Error in HTTP launch detection: {e}")
+                    try:
+                        print("\nKeeping HTTP servers alive. Press Ctrl+C to stop.")
+                        while True:
+                            time.sleep(1)
+                    except KeyboardInterrupt:
+                        print("\nServers stopped")
+            return None
+
+        elif protocol == "mcp":
+            if not self.agents:
+                logging.warning("No agents to launch for MCP mode. Add agents to the Agents instance first.")
+                return
+
             try:
-                # Process the query sequentially through all agents
-                current_input = query
-                results = []
+                import uvicorn
+                from mcp.server.fastmcp import FastMCP
+                from mcp.server.sse import SseServerTransport
+                from starlette.applications import Starlette
+                from starlette.requests import Request
+                from starlette.routing import Mount, Route
+                # from mcp.server import Server as MCPServer # Not directly needed if using FastMCP's server
+                import threading
+                import time
+                import inspect
+                import asyncio
+                # logging is already imported at the module level
                 
-                for agent in self.agents:
+            except ImportError as e:
+                missing_module = str(e).split("No module named '")[-1].rstrip("'")
+                display_error(f"Missing dependency: {missing_module}. Required for launch() method with MCP mode.")
+                logging.error(f"Missing dependency: {missing_module}. Required for launch() method with MCP mode.")
+                print(f"\nTo add MCP capabilities, install the required dependencies:")
+                print(f"pip install {missing_module} mcp praison-mcp starlette uvicorn")
+                print("\nOr install all MCP dependencies with relevant packages.")
+                return None
+
+            mcp_instance = FastMCP("praisonai_workflow_mcp_server")
+
+            # Determine the MCP tool name for the workflow based on self.name
+            actual_mcp_tool_name = (f"execute_{self.name.lower().replace(' ', '_').replace('-', '_')}_workflow" if self.name 
+                                    else "execute_workflow")
+
+            @mcp_instance.tool(name=actual_mcp_tool_name)
+            async def execute_workflow_tool(query: str) -> str: # Renamed for clarity
+                """Executes the defined agent workflow with the given query."""
+                logging.info(f"MCP tool '{actual_mcp_tool_name}' called with query: {query}")
+                current_input = query
+                final_response = "No agents in workflow or workflow did not produce a final response."
+
+                for agent_instance in self.agents:
                     try:
-                        # Use async version if available, otherwise use sync version
-                        if asyncio.iscoroutinefunction(agent.chat):
-                            response = await agent.achat(current_input)
-                        else:
-                            # Run sync function in a thread to avoid blocking
+                        logging.debug(f"Processing with agent: {agent_instance.name}")
+                        if hasattr(agent_instance, 'achat') and asyncio.iscoroutinefunction(agent_instance.achat):
+                            response = await agent_instance.achat(current_input, tools=agent_instance.tools)
+                        elif hasattr(agent_instance, 'chat'): # Fallback to sync chat if achat not suitable
                             loop = asyncio.get_event_loop()
-                            response = await loop.run_in_executor(None, lambda: agent.chat(current_input))
-                        
-                        # Store this agent's result
-                        results.append({
-                            "agent": agent.name,
-                            "response": response
-                        })
+                            response = await loop.run_in_executor(None, lambda ci=current_input: agent_instance.chat(ci, tools=agent_instance.tools))
+                        else:
+                            logging.warning(f"Agent {agent_instance.name} has no suitable chat or achat method.")
+                            response = f"Error: Agent {agent_instance.name} has no callable chat method."
                         
-                        # Use this response as input to the next agent
-                        current_input = response
+                        current_input = response if response is not None else "Agent returned no response."
+                        final_response = current_input # Keep track of the last valid response
+                        logging.debug(f"Agent {agent_instance.name} responded. Current intermediate output: {current_input}")
+
                     except Exception as e:
-                        logging.error(f"Error with agent {agent.name}: {str(e)}", exc_info=True)
-                        results.append({
-                            "agent": agent.name,
-                            "error": str(e)
-                        })
-                        # Continue with original input if there's an error
+                        logging.error(f"Error during agent {agent_instance.name} execution in MCP workflow: {str(e)}", exc_info=True)
+                        current_input = f"Error from agent {agent_instance.name}: {str(e)}"
+                        final_response = current_input # Update final response to show error
+                        # Optionally break or continue based on desired error handling for the workflow
+                        # For now, we continue, and the error is passed to the next agent or returned.
                 
-                # Return all results and the final output
-                return {
-                    "query": query,
-                    "results": results,
-                    "final_response": current_input
-                }
-            except Exception as e:
-                logging.error(f"Error processing query: {str(e)}", exc_info=True)
-                return JSONResponse(
-                    status_code=500,
-                    content={"error": f"Error processing query: {str(e)}"}
-                )
-        
-        print(f"🚀 Multi-Agent API available at http://{host}:{port}{path}")
-        agent_names = ", ".join([agent.name for agent in self.agents])
-        print(f"📊 Available agents ({len(self.agents)}): {agent_names}")
-        
-        # Start the server if it's not already running for this port
-        if not _agents_server_started.get(port, False):
-            # Mark the server as started first to prevent duplicate starts
-            _agents_server_started[port] = True
+                logging.info(f"MCP tool '{actual_mcp_tool_name}' completed. Final response: {final_response}")
+                return final_response
+
+            base_mcp_path = path.rstrip('/')
+            sse_mcp_path = f"{base_mcp_path}/sse"
+            messages_mcp_path_prefix = f"{base_mcp_path}/messages"
+            if not messages_mcp_path_prefix.endswith('/'):
+                messages_mcp_path_prefix += '/'
+
+            sse_transport_mcp = SseServerTransport(messages_mcp_path_prefix)
+
+            async def handle_mcp_sse_connection(request: Request) -> None:
+                logging.debug(f"MCP SSE connection request from {request.client} for path {request.url.path}")
+                async with sse_transport_mcp.connect_sse(
+                        request.scope, request.receive, request._send,
+                ) as (read_stream, write_stream):
+                    await mcp_instance._mcp_server.run(
+                        read_stream, write_stream, mcp_instance._mcp_server.create_initialization_options(),
+                    )
             
-            # Start the server in a separate thread
-            def run_server():
+            starlette_mcp_app = Starlette(
+                debug=debug,
+                routes=[
+                    Route(sse_mcp_path, endpoint=handle_mcp_sse_connection),
+                    Mount(messages_mcp_path_prefix, app=sse_transport_mcp.handle_post_message),
+                ],
+            )
+
+            print(f"🚀 PraisonAIAgents MCP Workflow server starting on http://{host}:{port}")
+            print(f"📡 MCP SSE endpoint available at {sse_mcp_path}")
+            print(f"📢 MCP messages post to {messages_mcp_path_prefix}")
+            # Instead of trying to extract tool names, hardcode the known tool name
+            mcp_tool_names = [actual_mcp_tool_name]  # Use the determined dynamic tool name
+            print(f"🛠️ Available MCP tools: {', '.join(mcp_tool_names)}")
+            agent_names_in_workflow = ", ".join([a.name for a in self.agents])
+            print(f"🔄 Agents in MCP workflow: {agent_names_in_workflow}")
+
+            def run_praison_mcp_server():
                 try:
-                    print(f"✅ FastAPI server started at http://{host}:{port}")
-                    print(f"📚 API documentation available at http://{host}:{port}/docs")
-                    print(f"🔌 Available endpoints: {', '.join(list(_agents_registered_endpoints[port].keys()))}")
-                    uvicorn.run(_agents_shared_apps[port], host=host, port=port, log_level="debug" if debug else "info")
+                    uvicorn.run(starlette_mcp_app, host=host, port=port, log_level="debug" if debug else "info")
                 except Exception as e:
-                    logging.error(f"Error starting server: {str(e)}", exc_info=True)
-                    print(f"❌ Error starting server: {str(e)}")
-            
-            # Run server in a background thread
-            server_thread = threading.Thread(target=run_server, daemon=True)
-            server_thread.start()
-            
-            # Wait for a moment to allow the server to start and register endpoints
-            time.sleep(0.5)
-        else:
-            # If server is already running, wait a moment to make sure the endpoint is registered
-            time.sleep(0.1)
-            print(f"🔌 Available endpoints on port {port}: {', '.join(list(_agents_registered_endpoints[port].keys()))}")
-        
-        # Get the stack frame to check if this is the last launch() call in the script
-        import inspect
-        stack = inspect.stack()
-        
-        # If this is called from a Python script (not interactive), try to detect if it's the last launch call
-        if len(stack) > 1 and stack[1].filename.endswith('.py'):
-            caller_frame = stack[1]
-            caller_line = caller_frame.lineno
-            
-            try:
-                # Read the file to check if there are more launch calls after this one
-                with open(caller_frame.filename, 'r') as f:
-                    lines = f.readlines()
-                
-                # Check if there are more launch() calls after the current line
-                has_more_launches = False
-                for line in lines[caller_line:]:
-                    if '.launch(' in line and not line.strip().startswith('#'):
-                        has_more_launches = True
-                        break
-                
-                # If this is the last launch call, block the main thread
-                if not has_more_launches:
+                    logging.error(f"Error starting PraisonAIAgents MCP server: {str(e)}", exc_info=True)
+                    print(f"❌ Error starting PraisonAIAgents MCP server: {str(e)}")
+
+            mcp_server_thread = threading.Thread(target=run_praison_mcp_server, daemon=True)
+            mcp_server_thread.start()
+            time.sleep(0.5) 
+
+            import inspect 
+            stack = inspect.stack()
+            if len(stack) > 1 and stack[1].filename.endswith('.py'):
+                caller_frame = stack[1]
+                caller_line = caller_frame.lineno
+                try:
+                    with open(caller_frame.filename, 'r') as f:
+                        lines = f.readlines()
+                    has_more_launches = False
+                    for line_content in lines[caller_line:]:
+                        if '.launch(' in line_content and not line_content.strip().startswith('#'):
+                            has_more_launches = True
+                            break
+                    if not has_more_launches:
+                        try:
+                            print("\nPraisonAIAgents MCP server running. Press Ctrl+C to stop.")
+                            while True:
+                                time.sleep(1)
+                        except KeyboardInterrupt:
+                            print("\nPraisonAIAgents MCP Server stopped")
+                except Exception as e:
+                    logging.error(f"Error in PraisonAIAgents MCP launch detection: {e}")
                     try:
-                        print("\nAll agents registered. Press Ctrl+C to stop the servers.")
+                        print("\nKeeping PraisonAIAgents MCP server alive. Press Ctrl+C to stop.")
                         while True:
                             time.sleep(1)
                     except KeyboardInterrupt:
-                        print("\nServers stopped")
-            except Exception as e:
-                # If something goes wrong with detection, block anyway to be safe
-                logging.error(f"Error in launch detection: {e}")
-                try:
-                    print("\nKeeping servers alive. Press Ctrl+C to stop.")
-                    while True:
-                        time.sleep(1)
-                except KeyboardInterrupt:
-                    print("\nServers stopped")
-        
-        return None 
+                        print("\nPraisonAIAgents MCP Server stopped")
+            return None
+        else:
+            display_error(f"Invalid protocol: {protocol}. Choose 'http' or 'mcp'.")
+            return None 

{praisonaiagents-0.0.80.dist-info → praisonaiagents-0.0.82.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.80
+Version: 0.0.82
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Dist: pydantic

{praisonaiagents-0.0.80.dist-info → praisonaiagents-0.0.82.dist-info}/RECORD

@@ -1,10 +1,10 @@
 praisonaiagents/__init__.py,sha256=Z2_rSA6mYozz0r3ioUgKzl3QV8uWRDS_QaqPg2oGjqg,1324
 praisonaiagents/main.py,sha256=l29nGEbV2ReBi4szURbnH0Fk0w2F_QZTmECysyZjYcA,15066
 praisonaiagents/agent/__init__.py,sha256=j0T19TVNbfZcClvpbZDDinQxZ0oORgsMrMqx16jZ-bA,128
-praisonaiagents/agent/agent.py,sha256=OOP_05mOMoHNkeElQWqH9jKOFUivlIjZ_vZJWLhIkSc,75089
+praisonaiagents/agent/agent.py,sha256=9vexAh3Jch5Fqst2aT-jf6xU1wAr4t0NePJZMmtVK_g,84183
 praisonaiagents/agent/image_agent.py,sha256=-5MXG594HVwSpFMcidt16YBp7udtik-Cp7eXlzLE1fY,8696
 praisonaiagents/agents/__init__.py,sha256=_1d6Pqyk9EoBSo7E68sKyd1jDRlN1vxvVIRpoMc0Jcw,168
-praisonaiagents/agents/agents.py,sha256=ABMQW07fH8HgY0adiwollDB5DQJZcf7uGhu4njiyIVM,49026
+praisonaiagents/agents/agents.py,sha256=HQXAuvV_cORa-NUNVknve4d0B1OIqS6W5jYkw_bYEyA,59519
 praisonaiagents/agents/autoagents.py,sha256=olYDn--rlJp-SckxILqmREkkgNlzCgEEcAUzfMj-54E,13518
 praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9bge0Ujuto,246
 praisonaiagents/knowledge/chunking.py,sha256=G6wyHa7_8V0_7VpnrrUXbEmUmptlT16ISJYaxmkSgmU,7678
@@ -40,7 +40,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.80.dist-info/METADATA,sha256=MAc45qEZryYHTSeN-iQ0Ia90WSHgKEDmu9ulXvfY8cw,1149
-praisonaiagents-0.0.80.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-praisonaiagents-0.0.80.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.80.dist-info/RECORD,,
+praisonaiagents-0.0.82.dist-info/METADATA,sha256=uo5CC4tD3LReN8VJ-jOmPvM7-6i6ZLqmJffuvwEbvVY,1149
+praisonaiagents-0.0.82.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+praisonaiagents-0.0.82.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.82.dist-info/RECORD,,

{praisonaiagents-0.0.80.dist-info → praisonaiagents-0.0.82.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.4.0)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: true
 Tag: py3-none-any