kailash 0.9.5__py3-none-any.whl → 0.9.7__py3-none-any.whl

kailash/__init__.py

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

kailash/nodes/ai/iterative_llm_agent.py

@@ -310,6 +310,7 @@ class IterativeLLMAgentNode(LLMAgentNode):
         convergence_reason = "max_iterations_reached"
 
         try:
+
             # Main iterative loop
             for iteration_num in range(1, max_iterations + 1):
                 iteration_state = IterationState(
@@ -694,7 +695,21 @@ class IterativeLLMAgentNode(LLMAgentNode):
             global_discoveries.get("tools", {}).values()
         )
 
-        # Simple planning logic (in real implementation, use LLM for planning)
+        # If we have no tools available, create a plan for direct LLM response
+        if not available_tools:
+            return {
+                "user_query": user_query,
+                "selected_tools": [],
+                "execution_steps": [
+                    {"step": 1, "action": "direct_llm_response", "tools": []}
+                ],
+                "expected_outcomes": ["direct_response"],
+                "resource_requirements": {},
+                "success_criteria": {"response_generated": True},
+                "planning_mode": "direct_llm",
+            }
+
+        # Create plan with available tools
         plan = {
             "user_query": user_query,
             "selected_tools": [],
@@ -702,6 +717,7 @@ class IterativeLLMAgentNode(LLMAgentNode):
             "expected_outcomes": [],
             "resource_requirements": {},
             "success_criteria": {},
+            "planning_mode": "tool_based",
         }
 
         # Select relevant tools
@@ -711,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"]}
             ]
@@ -754,6 +782,45 @@ class IterativeLLMAgentNode(LLMAgentNode):
         # Check if we should use real MCP tool execution
         use_real_mcp = kwargs.get("use_real_mcp", True)
 
+        # Handle direct LLM response mode
+        if plan.get("planning_mode") == "direct_llm":
+            try:
+                llm_response = super().run(**kwargs)
+
+                if llm_response.get("success") and llm_response.get("response"):
+                    content = llm_response["response"].get("content", "")
+                    step_result = {
+                        "step": 1,
+                        "action": "direct_llm_response",
+                        "tools_used": [],
+                        "output": content,
+                        "success": True,
+                        "duration": 2.0,  # Estimate for LLM call
+                        "llm_response": llm_response,
+                    }
+
+                    execution_results["steps_completed"].append(step_result)
+                    execution_results["intermediate_results"].append(content)
+                    execution_results["tool_outputs"]["llm_response"] = content
+                else:
+                    raise Exception(
+                        f"LLM response failed: {llm_response.get('error', 'Unknown error')}"
+                    )
+
+            except Exception as e:
+                error_result = {
+                    "step": 1,
+                    "action": "direct_llm_response",
+                    "tools_used": [],
+                    "error": str(e),
+                    "success": False,
+                }
+                execution_results["steps_completed"].append(error_result)
+                execution_results["errors"].append(str(e))
+                execution_results["success"] = False
+
+            return execution_results
+
         # Execute each step in the plan
         for step in plan.get("execution_steps", []):
             step_num = step.get("step", 0)
@@ -761,12 +828,12 @@ class IterativeLLMAgentNode(LLMAgentNode):
             tools = step.get("tools", [])
 
             try:
-                if use_real_mcp:
+                if use_real_mcp and tools:
                     # Real MCP tool execution
                     step_result = self._execute_tools_with_mcp(
                         step_num, action, tools, discoveries, kwargs
                     )
-                else:
+                elif tools:
                     # Mock tool execution for backward compatibility
                     step_result = {
                         "step": step_num,
@@ -776,20 +843,52 @@ class IterativeLLMAgentNode(LLMAgentNode):
                         "success": True,
                         "duration": 1.5,
                     }
+                else:
+                    # No tools available, try direct LLM call for this step
+                    self.logger.info(
+                        f"No tools for step {step_num}, using direct LLM call"
+                    )
+                    step_messages = [
+                        {
+                            "role": "user",
+                            "content": f"Please {action}: {plan.get('user_query', '')}",
+                        }
+                    ]
+                    step_kwargs = {**kwargs, "messages": step_messages}
+                    llm_response = super().run(**step_kwargs)
+
+                    if llm_response.get("success") and llm_response.get("response"):
+                        content = llm_response["response"].get("content", "")
+                        step_result = {
+                            "step": step_num,
+                            "action": action,
+                            "tools_used": [],
+                            "output": content,
+                            "success": True,
+                            "duration": 2.0,
+                        }
+                    else:
+                        raise Exception(f"LLM call failed for step {step_num}")
 
                 execution_results["steps_completed"].append(step_result)
                 execution_results["intermediate_results"].append(step_result["output"])
 
                 # Store tool outputs
-                for tool in tools:
-                    if step_result["success"]:
-                        execution_results["tool_outputs"][tool] = step_result.get(
-                            "tool_outputs", {}
-                        ).get(tool, step_result["output"])
-                    else:
-                        execution_results["tool_outputs"][
-                            tool
-                        ] = f"Error executing {tool}: {step_result.get('error', 'Unknown error')}"
+                if tools:
+                    for tool in tools:
+                        if step_result["success"]:
+                            execution_results["tool_outputs"][tool] = step_result.get(
+                                "tool_outputs", {}
+                            ).get(tool, step_result["output"])
+                        else:
+                            execution_results["tool_outputs"][
+                                tool
+                            ] = f"Error executing {tool}: {step_result.get('error', 'Unknown error')}"
+                else:
+                    # Store LLM response output
+                    execution_results["tool_outputs"][f"step_{step_num}_llm"] = (
+                        step_result["output"]
+                    )
 
             except Exception as e:
                 error_result = {
@@ -872,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
@@ -1520,7 +1668,58 @@ class IterativeLLMAgentNode(LLMAgentNode):
                     )
                     all_insights.extend(goals_achieved)
 
-        # Create synthesized response
+        # If we have no meaningful results from iterations, fall back to base LLM agent
+        if not all_results and not all_insights:
+            self.logger.info(
+                "No iterative results found, falling back to base LLM response"
+            )
+            try:
+                # Use parent's run method to get a proper LLM response
+                base_response = super().run(**kwargs)
+                if base_response.get("success") and base_response.get("response"):
+                    return base_response["response"].get("content", "")
+            except Exception as e:
+                self.logger.warning(f"Base LLM fallback failed: {e}")
+
+        # Create synthesized response using LLM
+        synthesis_messages = [
+            {
+                "role": "system",
+                "content": """You are an AI assistant synthesizing results from an iterative analysis process. 
+                Create a comprehensive, helpful response based on the findings from multiple iterations of analysis.""",
+            },
+            {
+                "role": "user",
+                "content": f"""Original query: {user_query}
+
+Results from {len(iterations)} iterations:
+{chr(10).join(all_results[:10]) if all_results else "No specific results generated"}
+
+Insights achieved:
+{chr(10).join(all_insights[:5]) if all_insights else "No specific insights achieved"}
+
+Please provide a comprehensive response to the original query based on these findings. If the findings are limited, 
+provide your best analysis of the query directly.""",
+            },
+        ]
+
+        try:
+            # Use the parent's LLM capabilities to generate synthesis
+            synthesis_kwargs = {
+                "provider": kwargs.get("provider", "openai"),
+                "model": kwargs.get("model", "gpt-4"),
+                "messages": synthesis_messages,
+                "temperature": kwargs.get("temperature", 0.7),
+                "max_tokens": kwargs.get("max_tokens", 1000),
+            }
+
+            synthesis_response = super().run(**synthesis_kwargs)
+            if synthesis_response.get("success") and synthesis_response.get("response"):
+                return synthesis_response["response"].get("content", "")
+        except Exception as e:
+            self.logger.warning(f"LLM synthesis failed: {e}")
+
+        # Fallback to basic synthesis if LLM fails
         synthesis = f"## Analysis Results for: {user_query}\n\n"
 
         if all_results:
@@ -1539,20 +1738,6 @@ class IterativeLLMAgentNode(LLMAgentNode):
             f"- {successful_iterations}/{len(iterations)} iterations successful\n\n"
         )
 
-        # Add confidence and evidence
-        final_confidence = 0.8  # Mock final confidence
-        synthesis += f"### Confidence: {final_confidence:.1%}\n"
-        synthesis += f"Based on analysis using {len(global_discoveries.get('tools', {}))} MCP tools and comprehensive iterative processing.\n\n"
-
-        # Add recommendations if analysis-focused
-        if "analyze" in user_query.lower() or "recommend" in user_query.lower():
-            synthesis += "### Recommendations:\n"
-            synthesis += (
-                "1. Continue monitoring key metrics identified in this analysis\n"
-            )
-            synthesis += "2. Consider implementing suggested improvements\n"
-            synthesis += "3. Review findings with stakeholders for validation\n"
-
         return synthesis
 
     def _update_global_discoveries(

kailash/nodes/base.py

@@ -1068,6 +1068,9 @@ class Node(ABC):
         if an object can be serialized. Used by validate_outputs()
         to identify problematic values.
 
+        Enhanced to recognize objects with .to_dict() methods and validate their output.
+        This resolves platform-specific serialization issues between LocalRuntime and Nexus.
+
         Args:
             obj: Any object to test for JSON serializability
 
@@ -1081,6 +1084,16 @@ class Node(ABC):
             json.dumps(obj)
             return True
         except (TypeError, ValueError):
+            # Check if object has .to_dict() method for enhanced validation
+            if hasattr(obj, "to_dict") and callable(getattr(obj, "to_dict")):
+                try:
+                    dict_result = obj.to_dict()
+                    # Validate that .to_dict() result is actually serializable
+                    json.dumps(dict_result)
+                    return True
+                except (TypeError, ValueError, AttributeError):
+                    # If .to_dict() fails or returns non-serializable data, fall back to False
+                    return False
             return False
 
     def execute(self, **runtime_inputs) -> dict[str, Any]:

{kailash-0.9.5.dist-info → kailash-0.9.7.dist-info}/METADATA

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

{kailash-0.9.5.dist-info → kailash-0.9.7.dist-info}/RECORD

@@ -1,4 +1,4 @@
-kailash/__init__.py,sha256=iwNjVBZF7kF09CsoOP8EUdmUe5uHc-Fdnl8RhXS2OYo,2771
+kailash/__init__.py,sha256=E3eRrjccUAH1875857yUosDh9qAHt-Inu_Q383PARDA,2771
 kailash/__main__.py,sha256=vr7TVE5o16V6LsTmRFKG6RDKUXHpIWYdZ6Dok2HkHnI,198
 kailash/access_control.py,sha256=MjKtkoQ2sg1Mgfe7ovGxVwhAbpJKvaepPWr8dxOueMA,26058
 kailash/access_control_abac.py,sha256=FPfa_8PuDP3AxTjdWfiH3ntwWO8NodA0py9W8SE5dno,30263
@@ -140,7 +140,7 @@ kailash/monitoring/__init__.py,sha256=C5WmkNpk_mmAScqMWiCfkUbjhM5W16dsnRnc3Ial-U
 kailash/monitoring/alerts.py,sha256=eKX4ooPw1EicumPuswlR_nU18UgRETWvFg8FzCW5pVU,21416
 kailash/monitoring/metrics.py,sha256=SiAnL3o6K0QaJHgfAuWBa-0pTkW5zymhuPEsj4bgOgM,22022
 kailash/nodes/__init__.py,sha256=p2KSo0dyUBCLClU123qpQ0tyv5S_36PTxosNyW58nyY,1031
-kailash/nodes/base.py,sha256=Mre45ucevCJo8y9gt1i_Ed4QsmemGeAZgA1jfBuTIbI,81870
+kailash/nodes/base.py,sha256=3KPCp2PDLCPGm4VHSHt8QSONLTX9y3UhQ-3ldQf4oUg,82623
 kailash/nodes/base_async.py,sha256=whxepCiVplrltfzEQuabmnGCpEV5WgfqwgxbLdCyiDk,8864
 kailash/nodes/base_cycle_aware.py,sha256=Xpze9xZzLepWeLpi9Y3tMn1dm2LVv-omr5TSQuGTtWo,13377
 kailash/nodes/base_with_acl.py,sha256=ZfrkLPgrEBcNbG0LKvtq6glDxyOYOMRw3VXX4vWX6bI,11852
@@ -166,7 +166,7 @@ kailash/nodes/ai/ai_providers.py,sha256=egfiOZzPmZ10d3wBCJ6ST4tRFrrtq0kt1VyCqxVp
 kailash/nodes/ai/embedding_generator.py,sha256=akGCzz7zLRSziqEQCiPwL2qWhRWxuM_1RQh-YtVEddw,31879
 kailash/nodes/ai/hybrid_search.py,sha256=k26uDDP_bwrIpv7Yl7PBCPvWSyQEmTlBjI1IpbgDsO4,35446
 kailash/nodes/ai/intelligent_agent_orchestrator.py,sha256=LvBqMKc64zSxFWVCjbLKKel2QwEzoTeJAEgna7rZw00,83097
-kailash/nodes/ai/iterative_llm_agent.py,sha256=T_Rtmz6E5gB0HugT2Q8FHZE9Giqy5WiBB0UCJ4PflNw,93308
+kailash/nodes/ai/iterative_llm_agent.py,sha256=G6pQnvSJcMBxloBvLBletFdiIRZGntNaMaVx2no0igY,101273
 kailash/nodes/ai/llm_agent.py,sha256=NeNJZbV_VOUbULug2LASwyzLyoUO5wi58Bc9sXTubuc,90181
 kailash/nodes/ai/models.py,sha256=wsEeUTuegy87mnLtKgSTg7ggCXvC1n3MsL-iZ4qujHs,16393
 kailash/nodes/ai/self_organizing.py,sha256=B7NwKaBW8OHQBf5b0F9bSs8Wm-5BDJ9IjIkxS9h00mg,62885
@@ -403,9 +403,9 @@ kailash/workflow/templates.py,sha256=XQMAKZXC2dlxgMMQhSEOWAF3hIbe9JJt9j_THchhAm8
 kailash/workflow/type_inference.py,sha256=i1F7Yd_Z3elTXrthsLpqGbOnQBIVVVEjhRpI0HrIjd0,24492
 kailash/workflow/validation.py,sha256=r2zApGiiG8UEn7p5Ji842l8OR1_KftzDkWc7gg0cac0,44675
 kailash/workflow/visualization.py,sha256=nHBW-Ai8QBMZtn2Nf3EE1_aiMGi9S6Ui_BfpA5KbJPU,23187
-kailash-0.9.5.dist-info/licenses/LICENSE,sha256=Axe6g7bTrJkToK9h9j2SpRUKKNaDZDCo2lQ2zPxCE6s,1065
-kailash-0.9.5.dist-info/METADATA,sha256=CdfS313HOOe7TPgBqpJaWlrycgXFgPXz_PI3FLihVwc,22298
-kailash-0.9.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kailash-0.9.5.dist-info/entry_points.txt,sha256=M_q3b8PG5W4XbhSgESzIJjh3_4OBKtZFYFsOdkr2vO4,45
-kailash-0.9.5.dist-info/top_level.txt,sha256=z7GzH2mxl66498pVf5HKwo5wwfPtt9Aq95uZUpH6JV0,8
-kailash-0.9.5.dist-info/RECORD,,
+kailash-0.9.7.dist-info/licenses/LICENSE,sha256=Axe6g7bTrJkToK9h9j2SpRUKKNaDZDCo2lQ2zPxCE6s,1065
+kailash-0.9.7.dist-info/METADATA,sha256=yo7vzKt8ikuCZCQBcsJeDPMm8VRW421kg8-U64whL0w,22298
+kailash-0.9.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kailash-0.9.7.dist-info/entry_points.txt,sha256=M_q3b8PG5W4XbhSgESzIJjh3_4OBKtZFYFsOdkr2vO4,45
+kailash-0.9.7.dist-info/top_level.txt,sha256=z7GzH2mxl66498pVf5HKwo5wwfPtt9Aq95uZUpH6JV0,8
+kailash-0.9.7.dist-info/RECORD,,