Increment version to 0.0.84 in pyproject.toml and uv.lock, update agent functionality in mcp-sse.py and openai-mcp.py for improved task handling, and enhance timeout management in MCP tools for better performance.

Author: MervinPraison

src/praisonai-agents/mcp-sse.py

@@ -1,9 +1,8 @@
 from praisonaiagents import Agent, MCP
 
-qa_agent = Agent(
-    instructions="""You are a Question Answering Agent.""",
-    llm="openai/gpt-4o-mini",
-    tools=MCP("http://localhost:8080/agents/sse")
+tweet_agent = Agent(
+    instructions="""You are a Tweet Formatter Agent.""",
+    tools=MCP("http://localhost:8080/sse")
 )
 
-qa_agent.start("AI in 2025")
+tweet_agent.start("AI in Healthcare")

src/praisonai-agents/openai-mcp.py

@@ -2,8 +2,7 @@
 
 search_agent = Agent(
     instructions="""You help book apartments on Airbnb.""",
-    llm="openai/gpt-4o-mini",
     tools=MCP("npx -y @openbnb/mcp-server-airbnb --ignore-robots-txt")
 )
 
-search_agent.start("I want to book an apartment in Paris for 2 nights. 03/28 - 03/30 for 2 adults")
+search_agent.start("Search apartment in Paris for 2 nights. 07/28 - 07/30 for 2 adults")

src/praisonai-agents/praisonaiagents/mcp/mcp.py

@@ -16,13 +16,14 @@
 class MCPToolRunner(threading.Thread):
     """A dedicated thread for running MCP operations."""
 
-    def __init__(self, server_params):
+    def __init__(self, server_params, timeout=60):
         super().__init__(daemon=True)
         self.server_params = server_params
         self.queue = queue.Queue()
         self.result_queue = queue.Queue()
         self.initialized = threading.Event()
         self.tools = []
+        self.timeout = timeout
         self.start()
 
     def run(self):
@@ -74,9 +75,9 @@ async def _run_async(self):
     def call_tool(self, tool_name, arguments):
         """Call an MCP tool and wait for the result."""
         if not self.initialized.is_set():
-            self.initialized.wait(timeout=30)
+            self.initialized.wait(timeout=self.timeout)
             if not self.initialized.is_set():
-                return "Error: MCP initialization timed out"
+                return f"Error: MCP initialization timed out after {self.timeout} seconds"
 
         # Put request in queue
         self.queue.put((tool_name, arguments))
@@ -189,7 +190,7 @@ def __init__(self, command_or_string=None, args=None, *, command=None, timeout=6
         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.sse_client = SSEMCPClient(command_or_string, debug=debug, timeout=timeout)
             self._tools = list(self.sse_client.tools)
             self.is_sse = True
             self.is_npx = False
@@ -216,11 +217,11 @@ def __init__(self, command_or_string=None, args=None, *, command=None, timeout=6
             args=arguments,
             **kwargs
         )
-        self.runner = MCPToolRunner(self.server_params)
+        self.runner = MCPToolRunner(self.server_params, timeout)
 
         # Wait for initialization
-        if not self.runner.initialized.wait(timeout=30):
-            print("Warning: MCP initialization timed out")
+        if not self.runner.initialized.wait(timeout=self.timeout):
+            print(f"Warning: MCP initialization timed out after {self.timeout} seconds")
 
         # Automatically detect if this is an NPX command
         self.is_npx = cmd == 'npx' or (isinstance(cmd, str) and os.path.basename(cmd) == 'npx')

src/praisonai-agents/praisonaiagents/mcp/mcp_sse.py

@@ -31,14 +31,15 @@ def get_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):
+    def __init__(self, name: str, description: str, session: ClientSession, input_schema: Optional[Dict[str, Any]] = None, timeout: int = 60):
         self.name = name
         self.__name__ = name  # Required for Agent to recognize it as a tool
         self.__qualname__ = name  # Required for Agent to recognize it as a tool
         self.__doc__ = description  # Required for Agent to recognize it as a tool
         self.description = description
         self.session = session
         self.input_schema = input_schema or {}
+        self.timeout = timeout
 
         # Create a signature based on input schema
         params = []
@@ -66,7 +67,7 @@ def __call__(self, **kwargs):
         future = asyncio.run_coroutine_threadsafe(self._async_call(**kwargs), loop)
         try:
             # Wait for the result with a timeout
-            return future.result(timeout=30)
+            return future.result(timeout=self.timeout)
         except Exception as e:
             logger.error(f"Error calling tool {self.name}: {e}")
             return f"Error: {str(e)}"
@@ -102,16 +103,18 @@ def to_openai_tool(self):
 class SSEMCPClient:
     """A client for connecting to an MCP server over SSE."""
 
-    def __init__(self, server_url: str, debug: bool = False):
+    def __init__(self, server_url: str, debug: bool = False, timeout: int = 60):
         """
         Initialize an SSE MCP client.
         
         Args:
             server_url: The URL of the SSE MCP server
             debug: Whether to enable debug logging
+            timeout: Timeout in seconds for operations (default: 60)
         """
         self.server_url = server_url
         self.debug = debug
+        self.timeout = timeout
         self.session = None
         self.tools = []
 
@@ -139,7 +142,7 @@ def run_event_loop():
 
         # Run the initialization in the event loop
         future = asyncio.run_coroutine_threadsafe(self._async_initialize(), loop)
-        self.tools = future.result(timeout=30)
+        self.tools = future.result(timeout=self.timeout)
 
     async def _async_initialize(self):
         """Asynchronously initialize the connection and tools."""
@@ -169,7 +172,8 @@ async def _async_initialize(self):
                 name=tool.name,
                 description=tool.description if hasattr(tool, 'description') else f"Call the {tool.name} tool",
                 session=self.session,
-                input_schema=input_schema
+                input_schema=input_schema,
+                timeout=self.timeout
             )
             tools.append(wrapper)
 

src/praisonai-agents/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.0.83"
+version = "0.0.84"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 authors = [
     { name="Mervin Praison" }

src/praisonai-agents/simple-mcp-server.py

@@ -1,4 +1,4 @@
 from praisonaiagents import Agent
 
-agent = Agent(name="TweetAgent", instructions="Create a Tweet based on the topic provided")
+agent = Agent(instructions="Create a Tweet")
 agent.launch(port=8080, protocol="mcp")