kailash 0.9.6__tar.gz → 0.9.8__tar.gz

{kailash-0.9.6/src/kailash.egg-info → kailash-0.9.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kailash
-Version: 0.9.6
+Version: 0.9.8
 Summary: Python SDK for the Kailash container-node architecture
 Home-page: https://github.com/integrum/kailash-python-sdk
 Author: Integrum

{kailash-0.9.6 → kailash-0.9.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kailash"
-version = "0.9.6"
+version = "0.9.8"
 description = "Python SDK for the Kailash container-node architecture"
 authors = [
     {name = "Integrum", email = "info@integrum.com"}

{kailash-0.9.6 → kailash-0.9.8}/src/kailash/__init__.py

@@ -50,7 +50,7 @@ except ImportError:
 # For backward compatibility
 WorkflowGraph = Workflow
 
-__version__ = "0.9.6"
+__version__ = "0.9.8"
 
 __all__ = [
     # Core workflow components

{kailash-0.9.6 → kailash-0.9.8}/src/kailash/nodes/ai/iterative_llm_agent.py

@@ -727,26 +727,38 @@ class IterativeLLMAgentNode(LLMAgentNode):
             elif isinstance(tool, dict):
                 plan["selected_tools"].append(tool.get("name", "unknown"))
 
-        # Create execution steps
+        # Create execution steps based on query and available tools
         if "analyze" in user_query.lower():
+            # For analysis queries, create multi-step plan
             plan["execution_steps"] = [
                 {
                     "step": 1,
                     "action": "gather_data",
-                    "tools": plan["selected_tools"][:1],
+                    "tools": (
+                        plan["selected_tools"][:1] if plan["selected_tools"] else []
+                    ),
                 },
                 {
                     "step": 2,
                     "action": "perform_analysis",
-                    "tools": plan["selected_tools"][1:2],
+                    "tools": (
+                        plan["selected_tools"][1:2]
+                        if len(plan["selected_tools"]) > 1
+                        else []
+                    ),
                 },
                 {
                     "step": 3,
                     "action": "generate_insights",
-                    "tools": plan["selected_tools"][2:3],
+                    "tools": (
+                        plan["selected_tools"][2:3]
+                        if len(plan["selected_tools"]) > 2
+                        else []
+                    ),
                 },
             ]
         else:
+            # For other queries, single step execution
             plan["execution_steps"] = [
                 {"step": 1, "action": "execute_query", "tools": plan["selected_tools"]}
             ]
@@ -959,11 +971,60 @@ class IterativeLLMAgentNode(LLMAgentNode):
                 self.logger.error(f"Tool execution failed for {tool_name}: {e}")
 
         # Combine all tool outputs
-        step_result["output"] = (
-            "\n".join(tool_results)
-            if tool_results
-            else f"No tools executed for action: {action}"
-        )
+        if tool_results:
+            step_result["output"] = "\n".join(tool_results)
+        else:
+            # No tools were executed - fall back to LLM for this action
+            self.logger.info(
+                f"No MCP tools available for action: {action}, using LLM fallback"
+            )
+
+            # Extract user query from kwargs
+            messages = kwargs.get("messages", [])
+            user_query = ""
+            for msg in reversed(messages):
+                if msg.get("role") == "user":
+                    user_query = msg.get("content", "")
+                    break
+
+            # Create a prompt for the LLM to handle this action
+            action_prompt = f"Please {action} for the following request: {user_query}"
+            llm_messages = [
+                {
+                    "role": "system",
+                    "content": kwargs.get(
+                        "system_prompt", "You are a helpful AI assistant."
+                    ),
+                },
+                {"role": "user", "content": action_prompt},
+            ]
+
+            # Use parent's LLM capabilities
+            try:
+                llm_kwargs = {
+                    "provider": kwargs.get("provider", "openai"),
+                    "model": kwargs.get("model", "gpt-4"),
+                    "messages": llm_messages,
+                    "temperature": kwargs.get("temperature", 0.7),
+                    "max_tokens": kwargs.get("max_tokens", 1000),
+                }
+
+                llm_response = super().run(**llm_kwargs)
+
+                if llm_response.get("success") and llm_response.get("response"):
+                    content = llm_response["response"].get("content", "")
+                    step_result["output"] = f"LLM Response for {action}: {content}"
+                    step_result["success"] = True
+                else:
+                    step_result["output"] = (
+                        f"Failed to execute {action}: {llm_response.get('error', 'Unknown error')}"
+                    )
+                    step_result["success"] = False
+            except Exception as e:
+                self.logger.error(f"LLM fallback failed for action {action}: {e}")
+                step_result["output"] = f"Error executing {action}: {str(e)}"
+                step_result["success"] = False
+
         step_result["duration"] = time.time() - start_time
 
         # Mark as failed if no tools executed successfully

{kailash-0.9.6 → kailash-0.9.8}/src/kailash/nodes/base.py

@@ -216,17 +216,58 @@ class Node(ABC):
             )
             self.logger = logging.getLogger(f"kailash.nodes.{self.id}")
 
-            # Filter out internal fields from config
-            internal_fields = {
+            # Filter out internal fields from config with comprehensive parameter handling
+            # Get parameter definitions once and cache for both filtering and validation
+            try:
+                if not hasattr(self, "_temp_param_definitions"):
+                    self._temp_param_definitions = self.get_parameters()
+                defined_params = set(self._temp_param_definitions.keys())
+            except Exception as e:
+                # If get_parameters() fails, log but continue with safe defaults
+                self.logger.debug(
+                    f"Could not get parameter definitions during init: {e}"
+                )
+                defined_params = set()
+                self._temp_param_definitions = {}
+
+            # Comprehensive parameter filtering: handle ALL potential conflicts
+            # Fields that are always internal (never user parameters)
+            always_internal = {"metadata"}
+
+            # Fields that can be either internal or user parameters
+            potentially_user_params = {
                 "id",
                 "name",
                 "description",
                 "version",
                 "author",
                 "tags",
-                "metadata",
             }
-            self.config = {k: v for k, v in kwargs.items() if k not in internal_fields}
+
+            # Build dynamic filter list based on user-defined parameters
+            internal_fields = always_internal.copy()
+            for field in potentially_user_params:
+                if field not in defined_params:
+                    # Field is not user-defined, so treat as internal field
+                    internal_fields.add(field)
+                # If field IS user-defined, don't add to internal_fields (preserve it)
+
+            # Also filter any field that starts with metadata prefix or other internal patterns
+            # This handles cases like 'metadata_name', 'metadata_*', etc.
+            def is_internal_field(field_name: str) -> bool:
+                # Check if it's in our explicit internal fields list
+                if field_name in internal_fields:
+                    return True
+                # Check for metadata-related field patterns
+                if field_name.startswith("metadata_"):
+                    return True
+                # Check for other internal patterns
+                if field_name.startswith("_"):  # Private fields
+                    return True
+                return False
+
+            # Apply comprehensive filtering
+            self.config = {k: v for k, v in kwargs.items() if not is_internal_field(k)}
 
             # Parameter resolution cache - initialize before validation
             cache_size = int(
@@ -554,11 +595,23 @@ class Node(ABC):
         return bool(re.match(r"^\$\{[^}]+\}$", value))
 
     def _get_cached_parameters(self) -> dict[str, NodeParameter]:
-        """Get cached parameter definitions.
+        """Get cached parameter definitions with optimal performance.
+
+        Uses parameters cached during initialization to avoid duplicate get_parameters() calls.
 
         Returns:
             Dictionary of parameter definitions, cached for performance
         """
+        # First check if we have parameters cached from initialization
+        if hasattr(self, "_temp_param_definitions") and self._temp_param_definitions:
+            # Use cached parameters from init and clean up temporary cache
+            if self._cached_params is None:
+                self._cached_params = self._temp_param_definitions
+                # Clean up temporary cache to free memory
+                delattr(self, "_temp_param_definitions")
+            return self._cached_params
+
+        # Fallback to original behavior if no cached parameters from init
         if self._cached_params is None:
             try:
                 self._cached_params = self.get_parameters()

{kailash-0.9.6 → kailash-0.9.8/src/kailash.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kailash
-Version: 0.9.6
+Version: 0.9.8
 Summary: Python SDK for the Kailash container-node architecture
 Home-page: https://github.com/integrum/kailash-python-sdk
 Author: Integrum