kailash 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

kailash/nodes/ai/llm_agent.py

@@ -106,7 +106,7 @@ class LLMAgentNode(Node):
     Examples:
         >>> # Basic Q&A agent with OpenAI
         >>> agent = LLMAgentNode()
-        >>> result = agent.run(
+        >>> result = agent.execute(
         ...     provider="openai",
         ...     model="gpt-4",
         ...     messages=[
@@ -118,7 +118,7 @@ class LLMAgentNode(Node):
 
         >>> # Tool-calling agent
         >>> tool_agent = LLMAgentNode()
-        >>> result = tool_agent.run(
+        >>> result = tool_agent.execute(
         ...     provider="anthropic",
         ...     model="claude-3-sonnet",
         ...     messages=[{"role": "user", "content": "Create a report and email it"}],
@@ -139,7 +139,7 @@ class LLMAgentNode(Node):
 
         >>> # RAG agent with MCP integration
         >>> rag_agent = LLMAgentNode()
-        >>> result = rag_agent.run(
+        >>> result = rag_agent.execute(
         ...     provider="azure",
         ...     model="gpt-4-turbo",
         ...     messages=[{"role": "user", "content": "What are the compliance requirements?"}],
@@ -349,6 +349,20 @@ class LLMAgentNode(Node):
                 required=False,
                 description="Override default model pricing (per 1K tokens)",
             ),
+            "auto_execute_tools": NodeParameter(
+                name="auto_execute_tools",
+                type=bool,
+                required=False,
+                default=True,
+                description="Automatically execute tool calls from LLM",
+            ),
+            "tool_execution_config": NodeParameter(
+                name="tool_execution_config",
+                type=dict,
+                required=False,
+                default={},
+                description="Configuration for tool execution behavior",
+            ),
         }
 
     def run(self, **kwargs) -> dict[str, Any]:
@@ -393,7 +407,7 @@ class LLMAgentNode(Node):
             Basic usage with OpenAI:
 
             >>> agent = LLMAgentNode()
-            >>> result = agent.run(
+            >>> result = agent.execute(
             ...     provider="openai",
             ...     model="gpt-4",
             ...     messages=[
@@ -411,7 +425,7 @@ class LLMAgentNode(Node):
 
             Using Ollama with custom model:
 
-            >>> result = agent.run(
+            >>> result = agent.execute(
             ...     provider="ollama",
             ...     model="llama3.1:8b-instruct-q8_0",
             ...     messages=[
@@ -427,7 +441,7 @@ class LLMAgentNode(Node):
 
             With system prompt and conversation memory:
 
-            >>> result = agent.run(
+            >>> result = agent.execute(
             ...     provider="anthropic",
             ...     model="claude-3-sonnet-20240229",
             ...     system_prompt="You are a helpful coding assistant.",
@@ -444,7 +458,7 @@ class LLMAgentNode(Node):
 
             With tool calling:
 
-            >>> result = agent.run(
+            >>> result = agent.execute(
             ...     provider="openai",
             ...     model="gpt-4-turbo",
             ...     messages=[
@@ -475,7 +489,7 @@ class LLMAgentNode(Node):
 
             With RAG (Retrieval Augmented Generation):
 
-            >>> result = agent.run(
+            >>> result = agent.execute(
             ...     provider="openai",
             ...     model="gpt-4",
             ...     messages=[
@@ -498,7 +512,7 @@ class LLMAgentNode(Node):
 
             With MCP (Model Context Protocol) integration:
 
-            >>> result = agent.run(
+            >>> result = agent.execute(
             ...     provider="anthropic",
             ...     model="claude-3-opus-20240229",
             ...     messages=[
@@ -522,7 +536,7 @@ class LLMAgentNode(Node):
 
             Advanced configuration with all features:
 
-            >>> result = agent.run(
+            >>> result = agent.execute(
             ...     provider="openai",
             ...     model="gpt-4-turbo",
             ...     messages=[
@@ -559,7 +573,7 @@ class LLMAgentNode(Node):
 
             Error handling:
 
-            >>> result = agent.run(
+            >>> result = agent.execute(
             ...     provider="openai",
             ...     model="gpt-4",
             ...     messages=[{"role": "user", "content": "Hello"}]
@@ -589,6 +603,8 @@ class LLMAgentNode(Node):
         streaming = kwargs.get("streaming", False)
         timeout = kwargs.get("timeout", 120)
         max_retries = kwargs.get("max_retries", 3)
+        auto_execute_tools = kwargs.get("auto_execute_tools", True)
+        tool_execution_config = kwargs.get("tool_execution_config", {})
 
         # Check monitoring parameters
         enable_monitoring = kwargs.get("enable_monitoring", self.enable_monitoring)
@@ -616,10 +632,11 @@ class LLMAgentNode(Node):
             mcp_context_data = self._retrieve_mcp_context(mcp_servers, mcp_context)
 
             # Discover MCP tools if enabled
+            discovered_mcp_tools = []
             if auto_discover_tools and mcp_servers:
-                mcp_tools = self._discover_mcp_tools(mcp_servers)
+                discovered_mcp_tools = self._discover_mcp_tools(mcp_servers)
                 # Merge MCP tools with existing tools
-                tools = self._merge_tools(tools, mcp_tools)
+                tools = self._merge_tools(tools, discovered_mcp_tools)
 
             # Perform RAG retrieval if configured
             rag_context = self._perform_rag_retrieval(
@@ -657,6 +674,54 @@ class LLMAgentNode(Node):
                     provider, model, enriched_messages, tools, generation_config
                 )
 
+            # Handle tool execution if enabled and tools were called
+            if auto_execute_tools and response.get("tool_calls"):
+                tool_execution_rounds = 0
+                max_rounds = tool_execution_config.get("max_rounds", 5)
+
+                # Keep executing tools until no more tool calls or max rounds reached
+                while response.get("tool_calls") and tool_execution_rounds < max_rounds:
+                    tool_execution_rounds += 1
+
+                    # Execute all tool calls
+                    tool_results = self._execute_tool_calls(
+                        response["tool_calls"],
+                        tools,
+                        mcp_tools=discovered_mcp_tools,  # Track which tools are MCP
+                    )
+
+                    # Add assistant message with tool calls
+                    enriched_messages.append(
+                        {
+                            "role": "assistant",
+                            "content": response.get("content"),
+                            "tool_calls": response["tool_calls"],
+                        }
+                    )
+
+                    # Add tool results as tool messages
+                    for tool_result in tool_results:
+                        enriched_messages.append(
+                            {
+                                "role": "tool",
+                                "tool_call_id": tool_result["tool_call_id"],
+                                "content": tool_result["content"],
+                            }
+                        )
+
+                    # Get next response from LLM with tool results
+                    if provider == "mock":
+                        response = self._mock_llm_response(
+                            enriched_messages, tools, generation_config
+                        )
+                    else:
+                        response = self._provider_llm_response(
+                            provider, model, enriched_messages, tools, generation_config
+                        )
+
+                # Update final response metadata
+                response["tool_execution_rounds"] = tool_execution_rounds
+
             # Update conversation memory
             if conversation_id:
                 self._update_conversation_memory(
@@ -718,6 +783,7 @@ class LLMAgentNode(Node):
                     "mcp_resources_used": len(mcp_context_data),
                     "rag_documents_retrieved": len(rag_context.get("documents", [])),
                     "tools_available": len(tools),
+                    "tools_executed": response.get("tool_execution_rounds", 0),
                     "memory_tokens": conversation_memory.get("token_count", 0),
                 },
                 "metadata": {
@@ -985,7 +1051,7 @@ class LLMAgentNode(Node):
                 import asyncio
                 from datetime import datetime
 
-                from kailash.mcp import MCPClient
+                from kailash.mcp_server import MCPClient
 
                 # Initialize MCP client if not already done
                 if not hasattr(self, "_mcp_client"):
@@ -1182,7 +1248,7 @@ class LLMAgentNode(Node):
 
         if use_real_mcp:
             try:
-                from kailash.mcp import MCPClient
+                from kailash.mcp_server import MCPClient
 
                 # Initialize MCP client if not already done
                 if not hasattr(self, "_mcp_client"):
@@ -1515,6 +1581,13 @@ class LLMAgentNode(Node):
         """Generate mock LLM response for testing."""
         last_user_message = ""
         has_images = False
+        has_tool_results = False
+
+        # Check if we have tool results in the conversation
+        for msg in messages:
+            if msg.get("role") == "tool":
+                has_tool_results = True
+                break
 
         for msg in reversed(messages):
             if msg.get("role") == "user":
@@ -1533,37 +1606,51 @@ class LLMAgentNode(Node):
                 break
 
         # Generate contextual mock response
-        if has_images:
+        if has_tool_results:
+            # We've executed tools, provide final response
+            response_content = "Based on the tool execution results, I've completed the requested task. The tools have been successfully executed and the operation is complete."
+            tool_calls = []  # No more tool calls after execution
+        elif has_images:
             response_content = "I can see the image(s) you've provided. Based on my analysis, [Mock vision response for testing]"
+            tool_calls = []
         elif "analyze" in last_user_message.lower():
             response_content = "Based on the provided data and context, I can see several key patterns: 1) Customer engagement has increased by 15% this quarter, 2) Product A shows the highest conversion rate, and 3) There are opportunities for improvement in the onboarding process."
+            tool_calls = []
         elif (
             "create" in last_user_message.lower()
             or "generate" in last_user_message.lower()
         ):
             response_content = "I'll help you create that. Based on the requirements and available tools, I recommend a structured approach with the following steps..."
+            # Simulate tool calls if tools are available and no tools executed yet
+            tool_calls = []
+            if (
+                tools
+                and not has_tool_results
+                and any(
+                    keyword in last_user_message.lower()
+                    for keyword in ["create", "send", "execute", "run"]
+                )
+            ):
+                for tool in tools[:2]:  # Limit to first 2 tools
+                    tool_name = tool.get("function", {}).get(
+                        "name", tool.get("name", "unknown")
+                    )
+                    tool_calls.append(
+                        {
+                            "id": f"call_{hash(tool_name) % 10000}",
+                            "type": "function",
+                            "function": {
+                                "name": tool_name,
+                                "arguments": json.dumps({"mock": "arguments"}),
+                            },
+                        }
+                    )
         elif "?" in last_user_message:
             response_content = f"Regarding your question about '{last_user_message[:50]}...', here's what I found from the available context and resources..."
+            tool_calls = []
         else:
             response_content = f"I understand you want me to work with: '{last_user_message[:100]}...'. Based on the context provided, I can help you achieve this goal."
-
-        # Simulate tool calls if tools are available
-        tool_calls = []
-        if tools and any(
-            keyword in last_user_message.lower()
-            for keyword in ["create", "send", "execute", "run"]
-        ):
-            for tool in tools[:2]:  # Limit to first 2 tools
-                tool_calls.append(
-                    {
-                        "id": f"call_{hash(tool['name']) % 10000}",
-                        "type": "function",
-                        "function": {
-                            "name": tool["name"],
-                            "arguments": json.dumps({"mock": "arguments"}),
-                        },
-                    }
-                )
+            tool_calls = []
 
         return {
             "id": f"msg_{hash(last_user_message) % 100000}",
@@ -1767,7 +1854,7 @@ class LLMAgentNode(Node):
         server_config = mcp_tool.get("function", {}).get("mcp_server_config", {})
 
         try:
-            from kailash.mcp import MCPClient
+            from kailash.mcp_server import MCPClient
 
             # Initialize MCP client if not already done
             if not hasattr(self, "_mcp_client"):
@@ -1789,6 +1876,96 @@ class LLMAgentNode(Node):
             self.logger.error(f"MCP tool execution failed: {e}")
             return {"error": str(e), "success": False, "tool_name": tool_name}
 
+    def _execute_tool_calls(
+        self,
+        tool_calls: list[dict[str, Any]],
+        available_tools: list[dict[str, Any]],
+        mcp_tools: list[dict[str, Any]] | None = None,
+    ) -> list[dict[str, Any]]:
+        """Execute all tool calls from LLM response.
+
+        Args:
+            tool_calls: List of tool calls from LLM response
+            available_tools: All available tools (MCP + regular)
+            mcp_tools: Tools that came from MCP discovery
+
+        Returns:
+            List of tool results formatted for LLM consumption
+        """
+        tool_results = []
+        mcp_tools = mcp_tools or []
+
+        # Create lookup for MCP tools
+        mcp_tool_names = {
+            tool.get("function", {}).get("name"): tool for tool in mcp_tools
+        }
+
+        for tool_call in tool_calls:
+            try:
+                tool_name = tool_call.get("function", {}).get("name")
+                tool_id = tool_call.get("id")
+
+                # Check if this is an MCP tool
+                if tool_name in mcp_tool_names:
+                    # Execute via MCP
+                    result = self._run_async_in_sync_context(
+                        self._execute_mcp_tool_call(tool_call, mcp_tools)
+                    )
+                else:
+                    # Execute regular tool (future implementation)
+                    result = self._execute_regular_tool(tool_call, available_tools)
+
+                # Format successful result
+                tool_results.append(
+                    {
+                        "tool_call_id": tool_id,
+                        "content": (
+                            json.dumps(result)
+                            if isinstance(result, dict)
+                            else str(result)
+                        ),
+                    }
+                )
+
+            except Exception as e:
+                # Format error result
+                tool_name = tool_call.get("function", {}).get("name", "unknown")
+                self.logger.error(f"Tool execution failed for {tool_name}: {e}")
+                tool_results.append(
+                    {
+                        "tool_call_id": tool_call.get("id", "unknown"),
+                        "content": json.dumps(
+                            {"error": str(e), "tool": tool_name, "status": "failed"}
+                        ),
+                    }
+                )
+
+        return tool_results
+
+    def _execute_regular_tool(
+        self, tool_call: dict[str, Any], available_tools: list[dict[str, Any]]
+    ) -> dict[str, Any]:
+        """Execute a regular (non-MCP) tool.
+
+        Args:
+            tool_call: Tool call from LLM
+            available_tools: List of available tools
+
+        Returns:
+            Tool execution result
+        """
+        tool_name = tool_call.get("function", {}).get("name")
+        tool_args = json.loads(tool_call.get("function", {}).get("arguments", "{}"))
+
+        # For now, return a mock result
+        # In future, this could execute actual Python functions
+        return {
+            "status": "success",
+            "tool": tool_name,
+            "result": f"Executed {tool_name} with args: {tool_args}",
+            "note": "Regular tool execution not yet implemented",
+        }
+
     # Monitoring methods
     def _get_pricing(self, model: str) -> Dict[str, float]:
         """Get pricing for current model."""
@@ -2013,4 +2190,4 @@ class LLMAgentNode(Node):
 
     async def async_run(self, **kwargs) -> Dict[str, Any]:
         """Async execution method for enterprise integration."""
-        return self.run(**kwargs)
+        return self.execute(**kwargs)

kailash/nodes/ai/self_organizing.py

@@ -101,7 +101,7 @@ class AgentPoolManagerNode(Node):
         >>> assert "agent_id" in params
         >>>
         >>> # Test simple registration
-        >>> result = pool_manager.run(
+        >>> result = pool_manager.execute(
         ...     action="register",
         ...     agent_id="test_agent",
         ...     capabilities=["analysis"]
@@ -1481,7 +1481,7 @@ class SolutionEvaluatorNode(Node):
     Examples:
         >>> evaluator = SolutionEvaluatorNode()
         >>>
-        >>> result = evaluator.run(
+        >>> result = evaluator.execute(
         ...     solution={
         ...         "approach": "Clustering analysis",
         ...         "findings": ["3 distinct customer segments identified"],

kailash/nodes/alerts/discord.py

@@ -100,7 +100,7 @@ class DiscordAlertNode(AlertNode):
     Examples:
         >>> # Simple text alert
         >>> node = DiscordAlertNode()
-        >>> result = node.run(
+        >>> result = node.execute(
         ...     webhook_url="${DISCORD_ALERTS_WEBHOOK}",
         ...     title="Deployment Complete",
         ...     message="Version 1.2.3 deployed successfully",
@@ -108,7 +108,7 @@ class DiscordAlertNode(AlertNode):
         ... )
         >>>
         >>> # Rich embed with context
-        >>> result = node.run(
+        >>> result = node.execute(
         ...     webhook_url=webhook_url,
         ...     title="Error in Data Pipeline",
         ...     message="Failed to process customer data",
@@ -123,7 +123,7 @@ class DiscordAlertNode(AlertNode):
         ... )
         >>>
         >>> # Mention users and post to thread
-        >>> result = node.run(
+        >>> result = node.execute(
         ...     webhook_url=webhook_url,
         ...     title="Critical: Database Connection Lost",
         ...     alert_type="critical",
@@ -438,7 +438,7 @@ class DiscordAlertNode(AlertNode):
 
         for attempt in range(max_retries):
             try:
-                response = self.http_client.run(
+                response = self.http_client.execute(
                     url=url,
                     method="POST",
                     json_data=payload,

kailash/nodes/api/graphql.py

@@ -309,7 +309,7 @@ class GraphQLClientNode(Node):
             "retry_backoff": retry_backoff,
         }
 
-        http_result = self.http_node.run(**http_params)
+        http_result = self.http_node.execute(**http_params)
 
         # Process GraphQL-specific response
         response = http_result["response"]
@@ -387,26 +387,26 @@ class AsyncGraphQLClientNode(AsyncNode):
         async_run method for better performance.
 
         Args:
-            Same as GraphQLClientNode.run()
+            Same as GraphQLClientNode.execute()
 
         Returns:
-            Same as GraphQLClientNode.run()
+            Same as GraphQLClientNode.execute()
 
         Raises:
             NodeValidationError: If required parameters are missing or invalid
             NodeExecutionError: If the request fails
         """
         # Forward to the synchronous GraphQL node
-        return self.graphql_node.run(**kwargs)
+        return self.graphql_node.execute(**kwargs)
 
     async def async_run(self, **kwargs) -> dict[str, Any]:
         """Execute a GraphQL query or mutation asynchronously.
 
         Args:
-            Same as GraphQLClientNode.run()
+            Same as GraphQLClientNode.execute()
 
         Returns:
-            Same as GraphQLClientNode.run()
+            Same as GraphQLClientNode.execute()
 
         Raises:
             NodeValidationError: If required parameters are missing or invalid

kailash/nodes/api/http.py

@@ -12,16 +12,11 @@ from typing import Any
 
 import aiohttp
 import requests
-from pydantic import BaseModel
-
 from kailash.nodes.base import Node, NodeParameter, register_node
 from kailash.nodes.base_async import AsyncNode
 from kailash.sdk_exceptions import NodeExecutionError, NodeValidationError
-from kailash.utils.resource_manager import (
-    AsyncResourcePool,
-    ResourcePool,
-    managed_resource,
-)
+from kailash.utils.resource_manager import AsyncResourcePool, ResourcePool, managed_resource
+from pydantic import BaseModel
 
 
 class HTTPMethod(str, Enum):
@@ -146,7 +141,7 @@ class HTTPRequestNode(Node):
     Examples:
         >>> # Simple GET request
         >>> node = HTTPRequestNode()
-        >>> result = node.run(
+        >>> result = node.execute(
         ...     url="https://api.example.com/users",
         ...     method="GET",
         ...     headers={"Accept": "application/json"}
@@ -155,7 +150,7 @@ class HTTPRequestNode(Node):
         >>> assert isinstance(result["content"], dict)
         >>>
         >>> # POST request with JSON body
-        >>> result = node.run(
+        >>> result = node.execute(
         ...     url="https://api.example.com/users",
         ...     method="POST",
         ...     json_data={"name": "John", "email": "john@example.com"},
@@ -165,7 +160,7 @@ class HTTPRequestNode(Node):
         >>> assert result["headers"]["content-type"].startswith("application/json")
         >>>
         >>> # Form data submission
-        >>> result = node.run(
+        >>> result = node.execute(
         ...     url="https://api.example.com/form",
         ...     method="POST",
         ...     data={"field1": "value1", "field2": "value2"},
@@ -173,7 +168,7 @@ class HTTPRequestNode(Node):
         ... )
         >>>
         >>> # File upload with multipart
-        >>> result = node.run(
+        >>> result = node.execute(
         ...     url="https://api.example.com/upload",
         ...     method="POST",
         ...     files={"file": ("data.csv", b"col1,col2\\n1,2", "text/csv")},
@@ -181,7 +176,7 @@ class HTTPRequestNode(Node):
         ... )
         >>>
         >>> # Error handling example
-        >>> result = node.run(
+        >>> result = node.execute(
         ...     url="https://api.example.com/protected",
         ...     method="GET"
         ... )
@@ -775,26 +770,26 @@ class AsyncHTTPRequestNode(AsyncNode):
         async_run method for better performance.
 
         Args:
-            Same as HTTPRequestNode.run()
+            Same as HTTPRequestNode.execute()
 
         Returns:
-            Same as HTTPRequestNode.run()
+            Same as HTTPRequestNode.execute()
 
         Raises:
             NodeExecutionError: If the request fails or returns an error status
         """
         # For compatibility, create a requests.Session() and use it
         http_node = HTTPRequestNode(**self.config)
-        return http_node.run(**kwargs)
+        return http_node.execute(**kwargs)
 
     async def async_run(self, **kwargs) -> dict[str, Any]:
         """Execute an HTTP request asynchronously.
 
         Args:
-            Same as HTTPRequestNode.run()
+            Same as HTTPRequestNode.execute()
 
         Returns:
-            Same as HTTPRequestNode.run()
+            Same as HTTPRequestNode.execute()
 
         Raises:
             NodeExecutionError: If the request fails or returns an error status

kailash/nodes/api/rate_limiting.py

@@ -360,7 +360,7 @@ class RateLimitedAPINode(Node):
 
         # If rate limiting is disabled, just pass through
         if not respect_rate_limits:
-            result = self.wrapped_node.run(**kwargs)
+            result = self.wrapped_node.execute(**kwargs)
             result["rate_limit_metadata"] = {"rate_limiting_active": False}
             return result
 
@@ -375,7 +375,7 @@ class RateLimitedAPINode(Node):
                 if self.rate_limiter.consume():
                     start_time = time.time()
                     try:
-                        result = self.wrapped_node.run(**kwargs)
+                        result = self.wrapped_node.execute(**kwargs)
                         execution_time = time.time() - start_time
 
                         # Add rate limiting metadata
@@ -482,9 +482,9 @@ class AsyncRateLimitedAPINode(AsyncNode):
             **kwargs: Parameters for the wrapped node
 
         Returns:
-            Same as RateLimitedAPINode.run()
+            Same as RateLimitedAPINode.execute()
         """
-        return self.sync_node.run(**kwargs)
+        return self.sync_node.execute(**kwargs)
 
     async def async_run(self, **kwargs) -> dict[str, Any]:
         """Execute the wrapped async node with rate limiting.