praisonaiagents 0.0.76__py3-none-any.whl → 0.0.78__py3-none-any.whl

praisonaiagents/agent/agent.py

@@ -22,9 +22,16 @@ import inspect
 import uuid
 from dataclasses import dataclass
 
+# Don't import FastAPI dependencies here - use lazy loading instead
+
 if TYPE_CHECKING:
     from ..task.task import Task
 
+# Shared variables for API server
+_shared_app = None
+_server_started = False
+_registered_agents = {}
+
 @dataclass
 class ChatCompletionMessage:
     content: str
@@ -530,11 +537,21 @@ Your Goal: {self.goal}
         from ..mcp.mcp import MCP
         if isinstance(self.tools, MCP):
             logging.debug(f"Looking for MCP tool {function_name}")
-            # Check if any of the MCP tools match the function name
-            for mcp_tool in self.tools.runner.tools:
-                if hasattr(mcp_tool, 'name') and mcp_tool.name == function_name:
-                    logging.debug(f"Found matching MCP tool: {function_name}")
-                    return self.tools.runner.call_tool(function_name, arguments)
+            
+            # Handle SSE MCP client
+            if hasattr(self.tools, 'is_sse') and self.tools.is_sse:
+                if hasattr(self.tools, 'sse_client'):
+                    for tool in self.tools.sse_client.tools:
+                        if tool.name == function_name:
+                            logging.debug(f"Found matching SSE MCP tool: {function_name}")
+                            return tool(**arguments)
+            # Handle stdio MCP client
+            elif hasattr(self.tools, 'runner'):
+                # Check if any of the MCP tools match the function name
+                for mcp_tool in self.tools.runner.tools:
+                    if hasattr(mcp_tool, 'name') and mcp_tool.name == function_name:
+                        logging.debug(f"Found matching MCP tool: {function_name}")
+                        return self.tools.runner.call_tool(function_name, arguments)
 
         # Try to find the function in the agent's tools list first
         func = None
@@ -815,7 +832,11 @@ Your Goal: {self.goal}
                         logging.debug("Converting MCP tool to OpenAI format")
                         openai_tool = tool_param.to_openai_tool()
                         if openai_tool:
-                            tool_param = [openai_tool]
+                            # Handle both single tool and list of tools
+                            if isinstance(openai_tool, list):
+                                tool_param = openai_tool
+                            else:
+                                tool_param = [openai_tool]
                             logging.debug(f"Converted MCP tool: {tool_param}")
                 
                 # Pass everything to LLM class
@@ -1385,4 +1406,157 @@ Your Goal: {self.goal}
 
         except Exception as e:
             logging.error(f"Error in execute_tool_async: {str(e)}", exc_info=True)
-            return {"error": f"Error in execute_tool_async: {str(e)}"} 
+            return {"error": f"Error in execute_tool_async: {str(e)}"}
+
+    def launch(self, path: str = '/', port: int = 8000, host: str = '0.0.0.0', autostart: bool = True, debug: bool = False, blocking: bool = True):
+        """
+        Launch the agent as an HTTP API endpoint.
+        
+        Args:
+            path: API endpoint path (default: '/')
+            port: Server port (default: 8000)
+            host: Server host (default: '0.0.0.0')
+            autostart: Whether to start the server automatically (default: True)
+            debug: Enable debug mode for uvicorn (default: False)
+            blocking: If True, blocks the main thread to keep the server running (default: True)
+            
+        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
+            
+            # 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.")
+            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"
+            )
+            
+            # 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 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:
+                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:
+                # 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))
+                
+                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 this is the first launch call and autostart is True
+        if autostart and not _server_started:
+            _server_started = True
+            
+            # Add healthcheck endpoint
+            @_shared_app.get("/health")
+            async def healthcheck():
+                return {"status": "ok", "agents": list(_registered_agents.keys())}
+            
+            # Start the server in a separate thread to not block execution
+            import threading
+            def run_server():
+                try:
+                    uvicorn.run(_shared_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)}")
+            
+            server_thread = threading.Thread(target=run_server, daemon=True)
+            server_thread.start()
+            
+            # Give the server a moment to start up
+            import time
+            time.sleep(0.5)
+            
+            print(f"✅ FastAPI server started at http://{host}:{port}")
+            print(f"📚 API documentation available at http://{host}:{port}/docs")
+            
+            # If blocking is True, keep the main thread alive
+            if blocking:
+                print("\nServer is running in blocking mode. Press Ctrl+C to stop...")
+                try:
+                    while True:
+                        time.sleep(1)
+                except KeyboardInterrupt:
+                    print("\nServer stopped")
+            else:
+                # Note for non-blocking mode
+                print("\nNote: Server is running in a background thread. To keep it alive, either:")
+                print("1. Set blocking=True when calling launch()")
+                print("2. Keep your main application running")
+                print("3. Use a loop in your code to prevent the program from exiting")
+            
+        return None 

praisonaiagents/llm/llm.py

@@ -293,6 +293,12 @@ class LLM:
                     if isinstance(tool, dict) and 'type' in tool and tool['type'] == 'function':
                         logging.debug(f"Using pre-formatted OpenAI tool: {tool['function']['name']}")
                         formatted_tools.append(tool)
+                    # Handle lists of tools (e.g. from MCP.to_openai_tool())
+                    elif isinstance(tool, list):
+                        for subtool in tool:
+                            if isinstance(subtool, dict) and 'type' in subtool and subtool['type'] == 'function':
+                                logging.debug(f"Using pre-formatted OpenAI tool from list: {subtool['function']['name']}")
+                                formatted_tools.append(subtool)
                     elif callable(tool):
                         tool_def = self._generate_tool_definition(tool.__name__)
                         if tool_def:

praisonaiagents/mcp/__init__.py

@@ -1,5 +1,8 @@
 """
 Model Context Protocol (MCP) integration for PraisonAI Agents.
+
+This package provides classes and utilities for connecting to MCP servers
+using different transport methods (stdio, SSE, etc.).
 """
 from .mcp import MCP
 

praisonaiagents/mcp/mcp.py

@@ -6,6 +6,7 @@ import inspect
 import shlex
 import logging
 import os
+import re
 from typing import Any, List, Optional, Callable, Iterable, Union
 from functools import wraps, partial
 
@@ -126,6 +127,13 @@ class MCP:
             tools=MCP("/path/to/python /path/to/app.py")
         )
         
+        # Method 3: Using an SSE endpoint
+        agent = Agent(
+            instructions="You are a helpful assistant...",
+            llm="gpt-4o-mini",
+            tools=MCP("http://localhost:8080/sse")
+        )
+        
         agent.start("What is the stock price of Tesla?")
         ```
     """
@@ -139,6 +147,7 @@ class MCP:
                              - The command to run the MCP server (e.g., Python path)
                              - A complete command string (e.g., "/path/to/python /path/to/app.py")
                              - For NPX: 'npx' command with args for smithery tools
+                             - An SSE URL (e.g., "http://localhost:8080/sse")
             args: Arguments to pass to the command (when command_or_string is the command)
             command: Alternative parameter name for backward compatibility
             timeout: Timeout in seconds for MCP server initialization and tool calls (default: 60)
@@ -149,7 +158,44 @@ class MCP:
         if command_or_string is None and command is not None:
             command_or_string = command
         
-        # Handle the single string format
+        # Set up logging - default to WARNING level to hide INFO messages
+        if debug:
+            logging.getLogger("mcp-wrapper").setLevel(logging.DEBUG)
+            logging.getLogger("mcp-sse").setLevel(logging.DEBUG)
+            logging.getLogger("mcp.client").setLevel(logging.DEBUG)
+            logging.getLogger("sse").setLevel(logging.DEBUG)
+            logging.getLogger("mcp-server").setLevel(logging.DEBUG)
+            logging.getLogger("mcp-client").setLevel(logging.DEBUG)
+            logging.getLogger("_client").setLevel(logging.DEBUG)
+            logging.getLogger("httpx").setLevel(logging.DEBUG)
+            logging.getLogger("llm").setLevel(logging.DEBUG)
+        else:
+            # Set all MCP-related loggers to WARNING level by default
+            logging.getLogger("mcp-wrapper").setLevel(logging.WARNING)
+            logging.getLogger("mcp-sse").setLevel(logging.WARNING)
+            logging.getLogger("mcp.client").setLevel(logging.WARNING)
+            logging.getLogger("sse").setLevel(logging.WARNING)
+            logging.getLogger("mcp-server").setLevel(logging.WARNING)
+            logging.getLogger("mcp-client").setLevel(logging.WARNING)
+            logging.getLogger("_client").setLevel(logging.WARNING)
+            logging.getLogger("httpx").setLevel(logging.WARNING)
+            logging.getLogger("llm").setLevel(logging.WARNING)
+        
+        # Store additional parameters
+        self.timeout = timeout
+        self.debug = debug
+        
+        # Check if this is an SSE 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)
+            self._tools = list(self.sse_client.tools)
+            self.is_sse = True
+            self.is_npx = False
+            return
+            
+        # Handle the single string format for stdio client
         if isinstance(command_or_string, str) and args is None:
             # Split the string into command and args using shell-like parsing
             parts = shlex.split(command_or_string)
@@ -162,7 +208,9 @@ class MCP:
             # Use the original format with separate command and args
             cmd = command_or_string
             arguments = args or []
-            
+        
+        # Set up stdio client
+        self.is_sse = False
         self.server_params = StdioServerParameters(
             command=cmd,
             args=arguments,
@@ -173,13 +221,6 @@ class MCP:
         # Wait for initialization
         if not self.runner.initialized.wait(timeout=30):
             print("Warning: MCP initialization timed out")
-            
-        # Store additional parameters
-        self.timeout = timeout
-        self.debug = debug
-        
-        if debug:
-            logging.getLogger("mcp-wrapper").setLevel(logging.DEBUG)
         
         # Automatically detect if this is an NPX command
         self.is_npx = cmd == 'npx' or (isinstance(cmd, str) and os.path.basename(cmd) == 'npx')
@@ -199,6 +240,9 @@ class MCP:
         Returns:
             List[Callable]: Functions that can be used as tools
         """
+        if self.is_sse:
+            return list(self.sse_client.tools)
+            
         tool_functions = []
         
         for tool in self.runner.tools:
@@ -303,8 +347,6 @@ class MCP:
                 logging.error(f"Failed to initialize NPX MCP tools: {e}")
             raise RuntimeError(f"Failed to initialize NPX MCP tools: {e}")
     
-
-    
     def __iter__(self) -> Iterable[Callable]:
         """
         Allow the MCP instance to be used directly as an iterable of tools.
@@ -320,37 +362,43 @@ class MCP:
         provider/model format (e.g., "openai/gpt-4o-mini").
         
         Returns:
-            dict: OpenAI-compatible tool definition
+            dict or list: OpenAI-compatible tool definition(s)
         """
+        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()
+            
         # For simplicity, we'll convert the first tool only if multiple exist
         # More complex implementations could handle multiple tools
-        if not self.runner.tools:
+        if not hasattr(self, 'runner') or not self.runner.tools:
             logging.warning("No MCP tools available to convert to OpenAI format")
             return None
             
-        # Get the first tool's schema
-        tool = self.runner.tools[0]
+        # Convert all tools to OpenAI format
+        openai_tools = []
+        for tool in self.runner.tools:
+            # Create OpenAI tool definition
+            parameters = {}
+            if hasattr(tool, 'inputSchema') and tool.inputSchema:
+                parameters = tool.inputSchema
+            else:
+                # Create a minimal schema if none exists
+                parameters = {
+                    "type": "object",
+                    "properties": {},
+                    "required": []
+                }
+                
+            openai_tools.append({
+                "type": "function",
+                "function": {
+                    "name": tool.name,
+                    "description": tool.description if hasattr(tool, 'description') else f"Call the {tool.name} tool",
+                    "parameters": parameters
+                }
+            })
         
-        # Create OpenAI tool definition
-        parameters = {}
-        if hasattr(tool, 'inputSchema') and tool.inputSchema:
-            parameters = tool.inputSchema
-        else:
-            # Create a minimal schema if none exists
-            parameters = {
-                "type": "object",
-                "properties": {},
-                "required": []
-            }
-            
-        return {
-            "type": "function",
-            "function": {
-                "name": tool.name,
-                "description": tool.description if hasattr(tool, 'description') else f"Call the {tool.name} tool",
-                "parameters": parameters
-            }
-        }
+        return openai_tools
     
     def __del__(self):
         """Clean up resources when the object is garbage collected."""

praisonaiagents/mcp/mcp_sse.py

@@ -0,0 +1,184 @@
+"""
+SSE (Server-Sent Events) client implementation for MCP (Model Context Protocol).
+This module provides the necessary classes and functions to connect to an MCP server
+over SSE transport.
+"""
+
+import asyncio
+import logging
+import threading
+import inspect
+import json
+from typing import List, Dict, Any, Optional, Callable, Iterable
+
+from mcp import ClientSession
+from mcp.client.sse import sse_client
+
+logger = logging.getLogger("mcp-sse")
+
+# 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 SSEMCPTool:
+    """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):
+        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 {}
+        
+        # Create a signature based on input schema
+        params = []
+        if input_schema and 'properties' in input_schema:
+            for param_name in input_schema['properties']:
+                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
+                    )
+                )
+        
+        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=30)
+        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 to_openai_tool(self):
+        """Convert the tool to OpenAI format."""
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": self.input_schema
+            }
+        }
+
+
+class SSEMCPClient:
+    """A client for connecting to an MCP server over SSE."""
+    
+    def __init__(self, server_url: str, debug: bool = False):
+        """
+        Initialize an SSE MCP client.
+        
+        Args:
+            server_url: The URL of the SSE MCP server
+            debug: Whether to enable debug logging
+        """
+        self.server_url = server_url
+        self.debug = debug
+        self.session = None
+        self.tools = []
+        
+        # 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=30)
+    
+    async def _async_initialize(self):
+        """Asynchronously initialize the connection and tools."""
+        logger.debug(f"Connecting to MCP server at {self.server_url}")
+        
+        # Create SSE client
+        self._streams_context = sse_client(url=self.server_url)
+        streams = await self._streams_context.__aenter__()
+        
+        self._session_context = ClientSession(*streams)
+        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 = SSEMCPTool(
+                name=tool.name,
+                description=tool.description if hasattr(tool, 'description') else f"Call the {tool.name} tool",
+                session=self.session,
+                input_schema=input_schema
+            )
+            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] 

{praisonaiagents-0.0.76.dist-info → praisonaiagents-0.0.78.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.76
+Version: 0.0.78
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Dist: pydantic
@@ -19,8 +19,12 @@ Requires-Dist: chonkie>=1.0.2; extra == "knowledge"
 Provides-Extra: llm
 Requires-Dist: litellm>=1.50.0; extra == "llm"
 Requires-Dist: pydantic>=2.4.2; extra == "llm"
+Provides-Extra: api
+Requires-Dist: fastapi>=0.115.0; extra == "api"
+Requires-Dist: uvicorn>=0.34.0; extra == "api"
 Provides-Extra: all
 Requires-Dist: praisonaiagents[memory]; extra == "all"
 Requires-Dist: praisonaiagents[knowledge]; extra == "all"
 Requires-Dist: praisonaiagents[llm]; extra == "all"
 Requires-Dist: praisonaiagents[mcp]; extra == "all"
+Requires-Dist: praisonaiagents[api]; extra == "all"

{praisonaiagents-0.0.76.dist-info → praisonaiagents-0.0.78.dist-info}/RECORD

@@ -1,7 +1,7 @@
 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=nxi_39Zr75IEdb7Iv6cofZICYwEbD9Jritw_R6cQHGk,65851
+praisonaiagents/agent/agent.py,sha256=mkZOHL_qgZaiX_DXTgiDlMIfjTmrqeMpi088VCC_YOo,73946
 praisonaiagents/agent/image_agent.py,sha256=-5MXG594HVwSpFMcidt16YBp7udtik-Cp7eXlzLE1fY,8696
 praisonaiagents/agents/__init__.py,sha256=_1d6Pqyk9EoBSo7E68sKyd1jDRlN1vxvVIRpoMc0Jcw,168
 praisonaiagents/agents/agents.py,sha256=uAOHyn77noFvg3sYVFRhQUuc1LDpCMpfLND8CKOXAd4,37971
@@ -10,9 +10,10 @@ praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9b
 praisonaiagents/knowledge/chunking.py,sha256=G6wyHa7_8V0_7VpnrrUXbEmUmptlT16ISJYaxmkSgmU,7678
 praisonaiagents/knowledge/knowledge.py,sha256=Po0JZsgjYJrXdNSggmUGOWidZEF0f8xo4nhsZZfh8tY,13217
 praisonaiagents/llm/__init__.py,sha256=ttPQQJQq6Tah-0updoEXDZFKWtJAM93rBWRoIgxRWO8,689
-praisonaiagents/llm/llm.py,sha256=1WjHumxzuc8sj81NQ4uVEIetUOrb-i58HYLQW7vjV3M,87921
-praisonaiagents/mcp/__init__.py,sha256=IkYdrAK1bDQDm_0t3Wjt63Zwv3_IJgqz84Wqz9GH2iQ,111
-praisonaiagents/mcp/mcp.py,sha256=BPPf5AIPXx28PaJJqOg6T3NRyymQH9YAD-Km7Ma9-KA,13681
+praisonaiagents/llm/llm.py,sha256=5SII0qUgaVbDTHdNfq4foV_vAjSwilz9Mw6p_S5LZfk,88393
+praisonaiagents/mcp/__init__.py,sha256=ibbqe3_7XB7VrIcUcetkZiUZS1fTVvyMy_AqCSFG8qc,240
+praisonaiagents/mcp/mcp.py,sha256=Fub1x-LroOs8pQhmOLSislBLnoHHGzR0ARGyUTUMzsM,16270
+praisonaiagents/mcp/mcp_sse.py,sha256=xi5auCf83GMnsXzNEu5ooxNKjSdzKM5plB_DBn4RLzQ,6565
 praisonaiagents/memory/memory.py,sha256=I8dOTkrl1i-GgQbDcrFOsSruzJ7MiI6Ys37DK27wrUs,35537
 praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
 praisonaiagents/process/process.py,sha256=HPw84OhnKQW3EyrDkpoQu0DcpxThbrzR2hWUgwQh9Pw,59955
@@ -39,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.76.dist-info/METADATA,sha256=-xgefbRpP_4S8NlG_tI-DgXv_40a7rzHIxnYYM1vwgA,982
-praisonaiagents-0.0.76.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-praisonaiagents-0.0.76.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.76.dist-info/RECORD,,
+praisonaiagents-0.0.78.dist-info/METADATA,sha256=VwX1r4Ib2OxhTYVqSHpEluxljiGzNy7eifYi6wBRbTk,1149
+praisonaiagents-0.0.78.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+praisonaiagents-0.0.78.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.78.dist-info/RECORD,,

{praisonaiagents-0.0.76.dist-info → praisonaiagents-0.0.78.dist-info}/WHEEL

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