praisonaiagents 0.0.67__py3-none-any.whl → 0.0.69__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
             
@@ -430,15 +436,37 @@ class LLM:
                     
                     # Handle tool calls
                     if tool_calls and execute_tool_fn:
+                        # Convert tool_calls to a serializable format for all providers
+                        serializable_tool_calls = []
+                        for tc in tool_calls:
+                            if isinstance(tc, dict):
+                                serializable_tool_calls.append(tc)  # Already a dict
+                            else:
+                                # Convert object to dict
+                                serializable_tool_calls.append({
+                                    "id": tc.id,
+                                    "type": getattr(tc, 'type', "function"),
+                                    "function": {
+                                        "name": tc.function.name,
+                                        "arguments": tc.function.arguments
+                                    }
+                                })
                         messages.append({
                             "role": "assistant",
                             "content": response_text,
-                            "tool_calls": tool_calls
+                            "tool_calls": serializable_tool_calls
                         })
                         
                         for tool_call in tool_calls:
-                            function_name = tool_call["function"]["name"]
-                            arguments = json.loads(tool_call["function"]["arguments"])
+                            # Handle both object and dict access patterns
+                            if isinstance(tool_call, dict):
+                                function_name = tool_call["function"]["name"]
+                                arguments = json.loads(tool_call["function"]["arguments"])
+                                tool_call_id = tool_call["id"]
+                            else:
+                                function_name = tool_call.function.name
+                                arguments = json.loads(tool_call.function.arguments)
+                                tool_call_id = tool_call.id
 
                             logging.debug(f"[TOOL_EXEC_DEBUG] About to execute tool {function_name} with args: {arguments}")
                             tool_result = execute_tool_fn(function_name, arguments)
@@ -456,18 +484,11 @@ class LLM:
                                 logging.debug(f"[TOOL_EXEC_DEBUG] About to display tool call with message: {display_message}")
                                 display_tool_call(display_message, console=console)
                                 
-                                messages.append({
-                                    "role": "tool",
-                                    "tool_call_id": tool_call["id"],
-                                    "content": json.dumps(tool_result)
-                                })
-                            else:
-                                logging.debug("[TOOL_EXEC_DEBUG] Verbose mode off, not displaying tool call")
-                                messages.append({
-                                    "role": "tool",
-                                    "tool_call_id": tool_call["id"],
-                                    "content": "Function returned an empty output"
-                                })
+                            messages.append({
+                                "role": "tool",
+                                "tool_call_id": tool_call_id,
+                                "content": json.dumps(tool_result) if tool_result is not None else "Function returned an empty output"
+                            })
 
                         # If reasoning_steps is True, do a single non-streaming call
                         if reasoning_steps:
@@ -924,15 +945,37 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                 tool_calls = tool_response.choices[0].message.get("tool_calls")
                 
                 if tool_calls:
+                    # Convert tool_calls to a serializable format for all providers
+                    serializable_tool_calls = []
+                    for tc in tool_calls:
+                        if isinstance(tc, dict):
+                            serializable_tool_calls.append(tc)  # Already a dict
+                        else:
+                            # Convert object to dict
+                            serializable_tool_calls.append({
+                                "id": tc.id,
+                                "type": getattr(tc, 'type', "function"),
+                                "function": {
+                                    "name": tc.function.name,
+                                    "arguments": tc.function.arguments
+                                }
+                            })
                     messages.append({
                         "role": "assistant",
                         "content": response_text,
-                        "tool_calls": tool_calls
+                        "tool_calls": serializable_tool_calls
                     })
                     
                     for tool_call in tool_calls:
-                        function_name = tool_call.function.name
-                        arguments = json.loads(tool_call.function.arguments)
+                        # Handle both object and dict access patterns
+                        if isinstance(tool_call, dict):
+                            function_name = tool_call["function"]["name"]
+                            arguments = json.loads(tool_call["function"]["arguments"])
+                            tool_call_id = tool_call["id"]
+                        else:
+                            function_name = tool_call.function.name
+                            arguments = json.loads(tool_call.function.arguments)
+                            tool_call_id = tool_call.id
 
                         tool_result = await execute_tool_fn(function_name, arguments)
 
@@ -943,17 +986,11 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             else:
                                 display_message += "Function returned no output"
                             display_tool_call(display_message, console=console)
-                            messages.append({
-                                "role": "tool",
-                                "tool_call_id": tool_call.id,
-                                "content": json.dumps(tool_result)
-                            })
-                        else:
-                            messages.append({
-                                "role": "tool",
-                                "tool_call_id": tool_call.id,
-                                "content": "Function returned an empty output"
-                            })
+                        messages.append({
+                            "role": "tool",
+                            "tool_call_id": tool_call_id,
+                            "content": json.dumps(tool_result) if tool_result is not None else "Function returned an empty output"
+                        })
 
                     # Get response after tool calls
                     response_text = ""

praisonaiagents/mcp/mcp.py

@@ -313,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.67.dist-info → praisonaiagents-0.0.69.dist-info}/METADATA

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.67
+Version: 0.0.69
 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.67.dist-info → praisonaiagents-0.0.69.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,9 +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/llm/llm.py,sha256=9UhKoTcInXfCFFmQfBEzs3G0t4dJ4yoEpQ5eUG9VC0Q,76574
 praisonaiagents/mcp/__init__.py,sha256=IkYdrAK1bDQDm_0t3Wjt63Zwv3_IJgqz84Wqz9GH2iQ,111
-praisonaiagents/mcp/mcp.py,sha256=7EJo2Eyw89ePQzeKUzRZgW3E2ztLkMwQj2lCjFlzecQ,12281
+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
@@ -39,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.67.dist-info/METADATA,sha256=sGyO2OxLcuZGGmq-2WZHg9RIvSB1tLPFOUpEst8VeU0,830
-praisonaiagents-0.0.67.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-praisonaiagents-0.0.67.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.67.dist-info/RECORD,,
+praisonaiagents-0.0.69.dist-info/METADATA,sha256=ymaq8EM2AZeNlbT-ISjYgHXMHbnHpX53O_Hkcrb5KtA,856
+praisonaiagents-0.0.69.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+praisonaiagents-0.0.69.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.69.dist-info/RECORD,,