add

agentgraph/reconstruction/prompt_reconstructor.py

@@ -470,6 +470,140 @@ class PromptReconstructor:
                 
                 result["reconstructed_prompt"] = self._remove_line_numbers(complete_prompt)
                 
+        elif relation_type == "CONSUMED_BY":
+            # Input/Request consumed by Agent - This represents input routing/dispatch
+            if source["type"] == "Input" and target["type"] == "Agent":
+                # This represents the system routing user input to the appropriate specialist agent
+                input_content = source.get("raw_prompt", source["name"])
+                agent_name = target["name"]
+                agent_description = target.get("description", "")
+                interaction = relation.get("interaction_prompt", "")
+                
+                # This would be the routing/dispatch message from the system orchestrator
+                complete_prompt = f"SYSTEM ROUTING: Input Dispatch\n\n"
+                complete_prompt += f"User Input: {input_content}\n\n"
+                complete_prompt += f"🎯 ROUTING DECISION:\n"
+                complete_prompt += f"Selected Agent: {agent_name}\n"
+                
+                if agent_description:
+                    complete_prompt += f"Agent Expertise: {agent_description}\n"
+                
+                complete_prompt += f"\n📋 ROUTING RATIONALE:\n"
+                if interaction:
+                    complete_prompt += f"{interaction}\n"
+                else:
+                    complete_prompt += f"Input '{source['name']}' has been routed to {agent_name} based on the agent's specialized capabilities.\n"
+                
+                complete_prompt += f"\n🔄 NEXT STEP:\n"
+                complete_prompt += f"The system will now pass this input to {agent_name} for processing.\n"
+                
+                result["reconstructed_prompt"] = complete_prompt
+                
+        elif relation_type == "PRODUCES":
+            # Task produces Output - This represents the result generation
+            if source["type"] == "Task" and target["type"] == "Output":
+                task_name = source["name"]
+                output_name = target["name"]
+                output_content = target.get("raw_prompt", target["name"])
+                interaction = relation.get("interaction_prompt", "")
+                
+                # This represents the task completion and output generation
+                complete_prompt = f"TASK COMPLETION: Output Generation\n\n"
+                complete_prompt += f"Completed Task: {task_name}\n"
+                complete_prompt += f"Generated Output: {output_name}\n\n"
+                
+                complete_prompt += f"📤 OUTPUT DETAILS:\n"
+                complete_prompt += f"{output_content}\n\n"
+                
+                if interaction:
+                    complete_prompt += f"📋 GENERATION NOTES:\n{interaction}\n\n"
+                
+                complete_prompt += f"✅ STATUS: Task successfully completed and output ready for delivery.\n"
+                
+                result["reconstructed_prompt"] = complete_prompt
+                
+        elif relation_type == "DELIVERS_TO":
+            # Output delivers to Human - This represents final result delivery
+            if source["type"] == "Output" and target["type"] == "Human":
+                output_name = source["name"]
+                output_content = source.get("raw_prompt", source["name"])
+                human_name = target["name"]
+                interaction = relation.get("interaction_prompt", "")
+                
+                # This represents the final delivery to the end user
+                complete_prompt = f"FINAL DELIVERY: Output to User\n\n"
+                complete_prompt += f"📬 DELIVERING TO: {human_name}\n"
+                complete_prompt += f"📦 OUTPUT: {output_name}\n\n"
+                
+                complete_prompt += f"📄 CONTENT:\n{output_content}\n\n"
+                
+                if interaction:
+                    complete_prompt += f"📋 DELIVERY NOTES:\n{interaction}\n\n"
+                
+                complete_prompt += f"✅ DELIVERY STATUS: Output successfully delivered to user.\n"
+                
+                result["reconstructed_prompt"] = complete_prompt
+                
+        elif relation_type == "REQUIRED_BY":
+            # Tool required by Task - This represents tool dependency
+            if source["type"] == "Tool" and target["type"] == "Task":
+                tool_name = source["name"]
+                task_name = target["name"]
+                tool_desc = source.get("raw_prompt", "")
+                interaction = relation.get("interaction_prompt", "")
+                
+                # This represents a tool dependency check or preparation
+                complete_prompt = f"DEPENDENCY CHECK: Tool Requirement\n\n"
+                complete_prompt += f"🔧 REQUIRED TOOL: {tool_name}\n"
+                complete_prompt += f"📋 FOR TASK: {task_name}\n\n"
+                
+                if tool_desc:
+                    complete_prompt += f"🛠️ TOOL DESCRIPTION:\n{tool_desc}\n\n"
+                
+                if interaction:
+                    complete_prompt += f"📋 REQUIREMENT DETAILS:\n{interaction}\n\n"
+                
+                complete_prompt += f"✅ STATUS: Tool dependency verified and available for task execution.\n"
+                
+                result["reconstructed_prompt"] = complete_prompt
+                
+        elif relation_type == "SUBTASK_OF":
+            # Task is subtask of another Task - This represents task hierarchy
+            if source["type"] == "Task" and target["type"] == "Task":
+                subtask_name = source["name"]
+                parent_task_name = target["name"]
+                interaction = relation.get("interaction_prompt", "")
+                
+                # This represents task decomposition or hierarchy
+                complete_prompt = f"TASK HIERARCHY: Subtask Relationship\n\n"
+                complete_prompt += f"🎯 PARENT TASK: {parent_task_name}\n"
+                complete_prompt += f"📋 SUBTASK: {subtask_name}\n\n"
+                
+                if interaction:
+                    complete_prompt += f"📋 HIERARCHY DETAILS:\n{interaction}\n\n"
+                
+                complete_prompt += f"🔄 WORKFLOW: Subtask '{subtask_name}' is part of larger task '{parent_task_name}'.\n"
+                
+                result["reconstructed_prompt"] = complete_prompt
+                
+        elif relation_type == "INTERVENES":
+            # Agent intervenes in process - This represents intervention/oversight
+            agent_name = source["name"] if source["type"] == "Agent" else target["name"]
+            process_name = target["name"] if source["type"] == "Agent" else source["name"]
+            interaction = relation.get("interaction_prompt", "")
+            
+            # This represents agent intervention or oversight
+            complete_prompt = f"PROCESS INTERVENTION: Agent Oversight\n\n"
+            complete_prompt += f"👤 INTERVENING AGENT: {agent_name}\n"
+            complete_prompt += f"⚙️ TARGET PROCESS: {process_name}\n\n"
+            
+            if interaction:
+                complete_prompt += f"📋 INTERVENTION DETAILS:\n{interaction}\n\n"
+            
+            complete_prompt += f"🚨 ACTION: Agent '{agent_name}' is intervening in '{process_name}' for quality control or course correction.\n"
+            
+            result["reconstructed_prompt"] = complete_prompt
+                
         elif relation_type == "REQUIRES_TOOL" or relation_type == "NEXT":
             # These relations don't typically correspond to actual prompts in the execution
             # They are metadata that help establish dependencies and flow

debug_relations.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+"""
+Debug script to check why some relations aren't being detected as using specialized logic.
+"""
+
+import json
+import sys
+sys.path.append('/Users/zekunwu/Desktop/agent_monitoring/huggingface/AgentGraph')
+
+from agentgraph.reconstruction import PromptReconstructor
+
+def debug_relation_detection():
+    """Debug relation type detection."""
+    print("🔍 Debugging Relation Type Detection")
+    print("=" * 60)
+    
+    # Load sample data
+    kg_path = '/Users/zekunwu/Desktop/agent_monitoring/huggingface/AgentGraph/backend/database/samples/knowledge_graphs/kg_algorithm_sample_16.json'
+    
+    with open(kg_path, 'r') as f:
+        kg_data = json.load(f)
+    
+    kg = kg_data['graph_data']
+    reconstructor = PromptReconstructor(kg)
+    
+    # Test each relation type
+    relation_types = ["DELIVERS_TO", "PRODUCES", "REQUIRED_BY", "USES"]
+    
+    for rel_type in relation_types:
+        print(f"\n🧪 Testing {rel_type}:")
+        
+        type_relations = [r for r in kg['relations'] if r['type'] == rel_type]
+        
+        if not type_relations:
+            print(f"  ⚠️  No {rel_type} relations found")
+            continue
+            
+        relation = type_relations[0]
+        print(f"  📋 Relation: {relation['id']}")
+        print(f"     Source: {relation['source']} → Target: {relation['target']}")
+        
+        # Get entity types
+        source_entity = next(e for e in kg['entities'] if e['id'] == relation['source'])
+        target_entity = next(e for e in kg['entities'] if e['id'] == relation['target'])
+        
+        print(f"     Source type: {source_entity['type']}")
+        print(f"     Target type: {target_entity['type']}")
+        
+        # Test reconstruction
+        result = reconstructor.reconstruct_relation_prompt(relation['id'])
+        
+        if "error" in result:
+            print(f"  ❌ Error: {result['error']}")
+            continue
+        
+        prompt = result.get('reconstructed_prompt', '')
+        print(f"  📝 Prompt length: {len(prompt)} chars")
+        print(f"  📝 First 200 chars: {prompt[:200]}...")
+        
+        # Check for specialized logic indicators
+        indicators = ["TASK COMPLETION", "FINAL DELIVERY", "DEPENDENCY CHECK", "SYSTEM ROUTING"]
+        specialized = any(indicator in prompt for indicator in indicators)
+        
+        print(f"  🎯 Specialized logic detected: {'✅ Yes' if specialized else '❌ No'}")
+
+if __name__ == "__main__":
+    debug_relation_detection()

test_improved_relations.py

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+"""
+Test the improved relation handling in prompt reconstruction.
+Focus on CONSUMED_BY and other newly added relation types.
+"""
+
+import json
+import sys
+sys.path.append('/Users/zekunwu/Desktop/agent_monitoring/huggingface/AgentGraph')
+
+from agentgraph.reconstruction import PromptReconstructor
+
+def test_consumed_by_relation():
+    """Test the specific CONSUMED_BY relation that was problematic."""
+    print("🧪 Testing CONSUMED_BY Relation Handling")
+    print("=" * 60)
+    
+    # Load the sample with CONSUMED_BY relation
+    kg_path = '/Users/zekunwu/Desktop/agent_monitoring/huggingface/AgentGraph/backend/database/samples/knowledge_graphs/kg_algorithm_sample_16.json'
+    
+    with open(kg_path, 'r') as f:
+        kg_data = json.load(f)
+    
+    kg = kg_data['graph_data']
+    
+    # Initialize reconstructor
+    reconstructor = PromptReconstructor(kg)
+    
+    # Find the CONSUMED_BY relation
+    consumed_by_relations = [r for r in kg['relations'] if r['type'] == 'CONSUMED_BY']
+    
+    if not consumed_by_relations:
+        print("❌ No CONSUMED_BY relations found in sample")
+        return
+    
+    print(f"Found {len(consumed_by_relations)} CONSUMED_BY relation(s)")
+    
+    for relation in consumed_by_relations:
+        print(f"\n🔍 Testing relation: {relation['id']}")
+        print(f"   Source: {relation['source']} → Target: {relation['target']}")
+        print(f"   Interaction prompt: {relation.get('interaction_prompt', 'None')}")
+        
+        # Test the reconstruction
+        result = reconstructor.reconstruct_relation_prompt(relation['id'])
+        
+        if "error" in result:
+            print(f"❌ Error: {result['error']}")
+            continue
+        
+        print(f"\n✅ Reconstruction successful!")
+        print(f"📝 Generated prompt preview:")
+        print("-" * 40)
+        prompt = result.get('reconstructed_prompt', '')
+        # Show first 300 characters
+        print(prompt[:300] + "..." if len(prompt) > 300 else prompt)
+        print("-" * 40)
+        
+        # Check if it's no longer the generic fallback
+        if "SYSTEM ROUTING" in prompt:
+            print("✅ Using specialized CONSUMED_BY logic (not generic fallback)")
+        else:
+            print("⚠️  May still be using generic fallback")
+
+def test_all_relation_types():
+    """Test all supported relation types."""
+    print("\n\n🧪 Testing All Relation Types")
+    print("=" * 60)
+    
+    # Load a sample that has multiple relation types
+    kg_path = '/Users/zekunwu/Desktop/agent_monitoring/huggingface/AgentGraph/backend/database/samples/knowledge_graphs/kg_algorithm_sample_16.json'
+    
+    with open(kg_path, 'r') as f:
+        kg_data = json.load(f)
+    
+    kg = kg_data['graph_data']
+    
+    # Initialize reconstructor
+    reconstructor = PromptReconstructor(kg)
+    
+    # Get all relation types in this sample
+    relation_types = set(r['type'] for r in kg['relations'])
+    
+    print(f"Relation types found in sample: {sorted(relation_types)}")
+    
+    # Test each relation type
+    results = {}
+    for rel_type in sorted(relation_types):
+        print(f"\n🔍 Testing {rel_type} relations:")
+        
+        type_relations = [r for r in kg['relations'] if r['type'] == rel_type]
+        
+        for relation in type_relations[:1]:  # Test first one of each type
+            result = reconstructor.reconstruct_relation_prompt(relation['id'])
+            
+            if "error" in result:
+                results[rel_type] = "❌ Error"
+                print(f"  ❌ Error: {result['error']}")
+            else:
+                prompt = result.get('reconstructed_prompt', '')
+                
+                # Check prompt quality indicators
+                if len(prompt) < 50:
+                    results[rel_type] = "⚠️  Too short"
+                    print(f"  ⚠️  Prompt too short ({len(prompt)} chars)")
+                elif rel_type in prompt or "METADATA:" in prompt or "SYSTEM ROUTING:" in prompt:
+                    results[rel_type] = "✅ Specialized"
+                    print(f"  ✅ Using specialized logic ({len(prompt)} chars)")
+                else:
+                    results[rel_type] = "⚠️  Generic"
+                    print(f"  ⚠️  May be using generic fallback ({len(prompt)} chars)")
+    
+    # Summary
+    print(f"\n📊 RELATION TYPE COVERAGE SUMMARY:")
+    print("-" * 40)
+    for rel_type, status in results.items():
+        print(f"  {rel_type:15} → {status}")
+
+def demonstrate_improved_consumed_by():
+    """Show the improvement in CONSUMED_BY relation handling."""
+    print("\n\n🎯 CONSUMED_BY Improvement Demonstration")
+    print("=" * 60)
+    
+    # Load sample data
+    kg_path = '/Users/zekunwu/Desktop/agent_monitoring/huggingface/AgentGraph/backend/database/samples/knowledge_graphs/kg_algorithm_sample_16.json'
+    
+    with open(kg_path, 'r') as f:
+        kg_data = json.load(f)
+    
+    kg = kg_data['graph_data']
+    reconstructor = PromptReconstructor(kg)
+    
+    # Find the specific CONSUMED_BY relation we were asked about
+    consumed_by_relations = [r for r in kg['relations'] if r['type'] == 'CONSUMED_BY']
+    
+    if consumed_by_relations:
+        relation = consumed_by_relations[0]  # Take the first one
+        
+        print(f"📋 Original relation:")
+        print(f"   ID: {relation['id']}")
+        print(f"   Type: {relation['type']}")
+        print(f"   Source: {relation['source']} (Input)")
+        print(f"   Target: {relation['target']} (Agent)")
+        print(f"   Interaction: {relation.get('interaction_prompt', 'None')}")
+        
+        # Get source and target entities
+        source_entity = next(e for e in kg['entities'] if e['id'] == relation['source'])
+        target_entity = next(e for e in kg['entities'] if e['id'] == relation['target'])
+        
+        print(f"\n📋 Entity details:")
+        print(f"   Input: {source_entity['name']}")
+        print(f"   Agent: {target_entity['name']} - {target_entity.get('description', 'No description')}")
+        
+        # Reconstruct the prompt
+        result = reconstructor.reconstruct_relation_prompt(relation['id'])
+        
+        if "error" not in result:
+            print(f"\n✅ NEW IMPROVED PROMPT:")
+            print("=" * 50)
+            print(result['reconstructed_prompt'])
+            print("=" * 50)
+            
+            print(f"\n🎯 Key improvements:")
+            print("  ✅ Clear system routing semantics")
+            print("  ✅ Proper input → agent relationship")
+            print("  ✅ Explains the dispatch logic")
+            print("  ✅ Shows agent specialization")
+            print("  ✅ Indicates next workflow step")
+
+if __name__ == "__main__":
+    test_consumed_by_relation()
+    test_all_relation_types()
+    demonstrate_improved_consumed_by()
+    
+    print(f"\n🎉 Testing completed! CONSUMED_BY relation handling has been significantly improved.")