praisonaiagents 0.0.66__py3-none-any.whl → 0.0.68__py3-none-any.whl

praisonaiagents/agent/agent.py

@@ -421,6 +421,12 @@ class Agent:
                 # Pass the entire string so LiteLLM can parse provider/model
                 self.llm_instance = LLM(model=llm)
                 self._using_custom_llm = True
+                
+                # Ensure tools are properly accessible when using custom LLM
+                if tools:
+                    logging.debug(f"Tools passed to Agent with custom LLM: {tools}")
+                    # Store the tools for later use
+                    self.tools = tools
             except ImportError as e:
                 raise ImportError(
                     "LLM features requested but dependencies not installed. "
@@ -519,9 +525,20 @@ Your Goal: {self.goal}
         """
         logging.debug(f"{self.name} executing tool {function_name} with arguments: {arguments}")
 
+        # Special handling for MCP tools
+        # Check if tools is an MCP instance with the requested function name
+        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)
+
         # Try to find the function in the agent's tools list first
         func = None
-        for tool in self.tools:
+        for tool in self.tools if isinstance(self.tools, (list, tuple)) else []:
             if (callable(tool) and getattr(tool, '__name__', '') == function_name) or \
                (inspect.isclass(tool) and tool.__name__ == function_name):
                 func = tool
@@ -643,24 +660,64 @@ Your Goal: {self.goal}
                     logging.warning(f"Tool {tool} not recognized")
 
         try:
-            if stream:
-                # Process as streaming response with formatted tools
-                final_response = self._process_stream_response(
-                    messages, 
-                    temperature, 
-                    start_time, 
-                    formatted_tools=formatted_tools if formatted_tools else None,
-                    reasoning_steps=reasoning_steps
-                )
+            # Use the custom LLM instance if available
+            if self._using_custom_llm and hasattr(self, 'llm_instance'):
+                if stream:
+                    # Debug logs for tool info
+                    if formatted_tools:
+                        logging.debug(f"Passing {len(formatted_tools)} formatted tools to LLM instance: {formatted_tools}")
+                    
+                    # Use the LLM instance for streaming responses
+                    final_response = self.llm_instance.get_response(
+                        prompt=messages[1:],  # Skip system message as LLM handles it separately  
+                        system_prompt=messages[0]['content'] if messages and messages[0]['role'] == 'system' else None,
+                        temperature=temperature,
+                        tools=formatted_tools if formatted_tools else None,
+                        verbose=self.verbose,
+                        markdown=self.markdown,
+                        stream=True,
+                        console=self.console,
+                        execute_tool_fn=self.execute_tool,
+                        agent_name=self.name,
+                        agent_role=self.role,
+                        reasoning_steps=reasoning_steps
+                    )
+                else:
+                    # Non-streaming with custom LLM
+                    final_response = self.llm_instance.get_response(
+                        prompt=messages[1:],
+                        system_prompt=messages[0]['content'] if messages and messages[0]['role'] == 'system' else None,
+                        temperature=temperature,
+                        tools=formatted_tools if formatted_tools else None,
+                        verbose=self.verbose,
+                        markdown=self.markdown,
+                        stream=False,
+                        console=self.console,
+                        execute_tool_fn=self.execute_tool,
+                        agent_name=self.name,
+                        agent_role=self.role,
+                        reasoning_steps=reasoning_steps
+                    )
             else:
-                # Process as regular non-streaming response
-                final_response = client.chat.completions.create(
-                    model=self.llm,
-                    messages=messages,
-                    temperature=temperature,
-                    tools=formatted_tools if formatted_tools else None,
-                    stream=False
-                )
+                # Use the standard OpenAI client approach
+                if stream:
+                    # Process as streaming response with formatted tools
+                    final_response = self._process_stream_response(
+                        messages, 
+                        temperature, 
+                        start_time, 
+                        formatted_tools=formatted_tools if formatted_tools else None,
+                        reasoning_steps=reasoning_steps
+                    )
+                else:
+                    # Process as regular non-streaming response
+                    final_response = client.chat.completions.create(
+                        model=self.llm,
+                        messages=messages,
+                        temperature=temperature,
+                        tools=formatted_tools if formatted_tools else None,
+                        stream=False
+                    )
 
             tool_calls = getattr(final_response.choices[0].message, 'tool_calls', None)
 
@@ -748,13 +805,26 @@ Your Goal: {self.goal}
 
         if self._using_custom_llm:
             try:
+                # Special handling for MCP tools when using provider/model format
+                tool_param = self.tools if tools is None else tools
+                
+                # Convert MCP tool objects to OpenAI format if needed
+                if tool_param is not None:
+                    from ..mcp.mcp import MCP
+                    if isinstance(tool_param, MCP) and hasattr(tool_param, 'to_openai_tool'):
+                        logging.debug("Converting MCP tool to OpenAI format")
+                        openai_tool = tool_param.to_openai_tool()
+                        if openai_tool:
+                            tool_param = [openai_tool]
+                            logging.debug(f"Converted MCP tool: {tool_param}")
+                
                 # Pass everything to LLM class
                 response_text = self.llm_instance.get_response(
                     prompt=prompt,
                     system_prompt=f"{self.backstory}\n\nYour Role: {self.role}\n\nYour Goal: {self.goal}" if self.use_system_prompt else None,
                     chat_history=self.chat_history,
                     temperature=temperature,
-                    tools=self.tools if tools is None else tools,
+                    tools=tool_param,
                     output_json=output_json,
                     output_pydantic=output_pydantic,
                     verbose=self.verbose,

praisonaiagents/llm/llm.py

@@ -289,15 +289,21 @@ class LLM:
             if tools:
                 formatted_tools = []
                 for tool in tools:
-                    if callable(tool):
+                    # Check if the tool is already in OpenAI format (e.g. from MCP.to_openai_tool())
+                    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)
+                    elif callable(tool):
                         tool_def = self._generate_tool_definition(tool.__name__)
+                        if tool_def:
+                            formatted_tools.append(tool_def)
                     elif isinstance(tool, str):
                         tool_def = self._generate_tool_definition(tool)
+                        if tool_def:
+                            formatted_tools.append(tool_def)
                     else:
-                        continue
+                        logging.debug(f"Skipping tool of unsupported type: {type(tool)}")
                         
-                    if tool_def:
-                        formatted_tools.append(tool_def)
                 if not formatted_tools:
                     formatted_tools = None
             

praisonaiagents/mcp/__init__.py

@@ -0,0 +1,6 @@
+"""
+Model Context Protocol (MCP) integration for PraisonAI Agents.
+"""
+from .mcp import MCP
+
+__all__ = ["MCP"]

praisonaiagents/mcp/mcp.py

@@ -4,7 +4,9 @@ import queue
 import time
 import inspect
 import shlex
-from typing import Dict, Any, List, Optional, Callable, Iterable, Union
+import logging
+import os
+from typing import Any, List, Optional, Callable, Iterable, Union
 from functools import wraps, partial
 
 from mcp import ClientSession, StdioServerParameters
@@ -128,7 +130,7 @@ class MCP:
         ```
     """
     
-    def __init__(self, command_or_string=None, args=None, *, command=None, **kwargs):
+    def __init__(self, command_or_string=None, args=None, *, command=None, timeout=60, debug=False, **kwargs):
         """
         Initialize the MCP connection and get tools.
         
@@ -136,8 +138,11 @@ class MCP:
             command_or_string: Either:
                              - 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
             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)
+            debug: Enable debug logging for MCP operations (default: False)
             **kwargs: Additional parameters for StdioServerParameters
         """
         # Handle backward compatibility with named parameter 'command'
@@ -168,9 +173,24 @@ 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')
         
-        # Generate tool functions immediately and store them
-        self._tools = self._generate_tool_functions()
+        # For NPX-based MCP servers, use a different approach
+        if self.is_npx:
+            self._function_declarations = []
+            self._initialize_npx_mcp_tools(cmd, arguments)
+        else:
+            # Generate tool functions immediately and store them
+            self._tools = self._generate_tool_functions()
     
     def _generate_tool_functions(self) -> List[Callable]:
         """
@@ -264,6 +284,27 @@ class MCP:
         
         return wrapper
     
+    def _initialize_npx_mcp_tools(self, cmd, arguments):
+        """Initialize the NPX MCP tools by extracting tool definitions."""
+        try:
+            # For NPX tools, we'll use the same approach as regular MCP tools
+            # but we need to handle the initialization differently
+            if self.debug:
+                logging.debug(f"Initializing NPX MCP tools with command: {cmd} {' '.join(arguments)}")
+            
+            # Generate tool functions using the regular MCP approach
+            self._tools = self._generate_tool_functions()
+            
+            if self.debug:
+                logging.debug(f"Generated {len(self._tools)} NPX MCP tools")
+                
+        except Exception as e:
+            if self.debug:
+                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.
@@ -272,6 +313,45 @@ class MCP:
         """
         return iter(self._tools)
     
+    def to_openai_tool(self):
+        """Convert the MCP tool to an OpenAI-compatible tool definition.
+        
+        This method is specifically invoked by the Agent class when using
+        provider/model format (e.g., "openai/gpt-4o-mini").
+        
+        Returns:
+            dict: OpenAI-compatible tool definition
+        """
+        # For simplicity, we'll convert the first tool only if multiple exist
+        # More complex implementations could handle multiple tools
+        if 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]
+        
+        # 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
+            }
+        }
+    
     def __del__(self):
         """Clean up resources when the object is garbage collected."""
         if hasattr(self, 'runner'):

{praisonaiagents-0.0.66.dist-info → praisonaiagents-0.0.68.dist-info}/METADATA

@@ -1,11 +1,12 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.66
+Version: 0.0.68
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Dist: pydantic
 Requires-Dist: rich
 Requires-Dist: openai
+Requires-Dist: mcp==1.6.0
 Provides-Extra: memory
 Requires-Dist: chromadb>=0.5.23; extra == "memory"
 Provides-Extra: knowledge

{praisonaiagents-0.0.66.dist-info → praisonaiagents-0.0.68.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=h3s0-1M88zujllDHnKijHmYeVihD75d-K9s2Y3IHLY4,61850
+praisonaiagents/agent/agent.py,sha256=NiTUqkibCKW6Rx0HbR1peY3TtOcQl2O8XdrEV__gPlM,65805
 praisonaiagents/agent/image_agent.py,sha256=-5MXG594HVwSpFMcidt16YBp7udtik-Cp7eXlzLE1fY,8696
 praisonaiagents/agents/__init__.py,sha256=_1d6Pqyk9EoBSo7E68sKyd1jDRlN1vxvVIRpoMc0Jcw,168
 praisonaiagents/agents/agents.py,sha256=KLfSuz6nGEJM-n4xCXdtIkES6cUI-LwvMxI3R-MjrD0,37862
@@ -10,8 +10,9 @@ praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9b
 praisonaiagents/knowledge/chunking.py,sha256=FzoNY0q8MkvG4gADqk4JcRhmH3lcEHbRdonDgitQa30,6624
 praisonaiagents/knowledge/knowledge.py,sha256=fQNREDiwdoisfIxJBLVkteXgq_8Gbypfc3UaZbxf5QY,13210
 praisonaiagents/llm/__init__.py,sha256=ttPQQJQq6Tah-0updoEXDZFKWtJAM93rBWRoIgxRWO8,689
-praisonaiagents/llm/llm.py,sha256=6QMRW47fgFozibzaqxa3dwxlD756rMLCRjL3eNsw8QQ,74088
-praisonaiagents/mcp/mcp.py,sha256=xvORgbsbsdaY_j3jKCP8BH3ERoKi_ZK8zM57mobC2Ac,10488
+praisonaiagents/llm/llm.py,sha256=l7Z2QjD9eFy0Zq5bwTVK7VOUHxeTyx866YWt3fS3vz8,74606
+praisonaiagents/mcp/__init__.py,sha256=IkYdrAK1bDQDm_0t3Wjt63Zwv3_IJgqz84Wqz9GH2iQ,111
+praisonaiagents/mcp/mcp.py,sha256=BPPf5AIPXx28PaJJqOg6T3NRyymQH9YAD-Km7Ma9-KA,13681
 praisonaiagents/memory/memory.py,sha256=I8dOTkrl1i-GgQbDcrFOsSruzJ7MiI6Ys37DK27wrUs,35537
 praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
 praisonaiagents/process/process.py,sha256=HPw84OhnKQW3EyrDkpoQu0DcpxThbrzR2hWUgwQh9Pw,59955
@@ -38,7 +39,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.66.dist-info/METADATA,sha256=mZDRbV3kjDru4ehwjOVkMLJAKZeYq79yZB_8VjQDzUA,830
-praisonaiagents-0.0.66.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
-praisonaiagents-0.0.66.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.66.dist-info/RECORD,,
+praisonaiagents-0.0.68.dist-info/METADATA,sha256=wMy9WDu6aGcQWrQIFT1UMOfB-wcvrGqpeDwXqbQXIvM,856
+praisonaiagents-0.0.68.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+praisonaiagents-0.0.68.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.68.dist-info/RECORD,,

{praisonaiagents-0.0.66.dist-info → praisonaiagents-0.0.68.dist-info}/WHEEL

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