add

analyze_real_agent_trace.py

@@ -1,280 +0,0 @@
-#!/usr/bin/env python3
-"""
-Analyze Real Agent Trace for Prompt Reconstruction Enhancement
-
-This script analyzes the provided real agent trace to understand how we can
-enhance our prompt reconstruction to better simulate actual agent reasoning
-patterns and internal thought processes.
-"""
-
-import json
-import sys
-import os
-sys.path.append('/Users/zekunwu/Desktop/agent_monitoring/huggingface/AgentGraph')
-
-def analyze_real_trace_structure():
-    """Analyze the structure of the real agent trace."""
-    
-    print("🔍 REAL AGENT TRACE ANALYSIS")
-    print("=" * 70)
-    
-    # Simulate the provided trace structure
-    real_trace_example = {
-        "type": "ai",
-        "content": "",
-        "additional_kwargs": {
-            "reasoning_content": """We need to act as supervisor agent. The last user message: "write me final report for q1 2024!" We must follow instructions. The last message is the task. We need to produce final report. We must do steps: 1. Summarize request, period. 2. Retrieve data using get_order_data_for_period. Then delegate to revenue analyst, etc. We need to call tools accordingly. Let's do step 1: produce plan. Then step 2: call get_order_data_for_period with start_date 2024-01-01 end_date 2024-03-31...""",
-            "tool_calls": [
-                {
-                    "id": "fc_2372f7b7-2858-4b94-b5b2-4441ed19b66f",
-                    "function": {
-                        "arguments": {
-                            "end_date": "2024-03-31",
-                            "save_to_filename": "2024-01-01_to_2024-03-31_order.json",
-                            "start_date": "2024-01-01"
-                        },
-                        "name": "get_order_data_for_period"
-                    },
-                    "type": "function"
-                }
-            ]
-        },
-        "response_metadata": {
-            "token_usage": {
-                "completion_tokens": 533,
-                "prompt_tokens": 2105,
-                "total_tokens": 2638
-            },
-            "model_name": "openai/gpt-oss-20b"
-        }
-    }
-    
-    print("📊 Key Components in Real Agent Trace:")
-    print("─" * 50)
-    print("✅ reasoning_content: Agent's internal thinking process")
-    print("✅ tool_calls: Structured function calls with arguments")
-    print("✅ response_metadata: Token usage and model information")
-    print("✅ content: Public response (often empty when using tools)")
-    print()
-    
-    reasoning_content = real_trace_example["additional_kwargs"]["reasoning_content"]
-    print(f"🧠 Reasoning Content Analysis:")
-    print(f"  Length: {len(reasoning_content)} characters")
-    print(f"  Contains planning: {'step' in reasoning_content.lower()}")
-    print(f"  Contains decision making: {'need to' in reasoning_content.lower()}")
-    print(f"  Contains self-reflection: {'but' in reasoning_content.lower()}")
-    print()
-    
-    tool_call = real_trace_example["additional_kwargs"]["tool_calls"][0]
-    print(f"🔧 Tool Call Analysis:")
-    print(f"  Function: {tool_call['function']['name']}")
-    print(f"  Arguments: {len(tool_call['function']['arguments'])} parameters")
-    print(f"  ID: {tool_call['id']}")
-
-def extract_agent_reasoning_patterns():
-    """Extract and analyze agent reasoning patterns from the trace."""
-    
-    print(f"\n🎯 AGENT REASONING PATTERNS")
-    print("=" * 70)
-    
-    # Extract key reasoning patterns from the provided trace
-    reasoning_patterns = {
-        "task_analysis": {
-            "pattern": "The last user message: \"write me final report for q1 2024!\"",
-            "description": "Agent identifies and quotes the user's request"
-        },
-        "instruction_following": {
-            "pattern": "We must follow instructions. The last message is the task.",
-            "description": "Agent acknowledges constraints and task definition"
-        },
-        "step_planning": {
-            "pattern": "We must do steps: 1. Summarize request, period. 2. Retrieve data...",
-            "description": "Agent breaks down complex tasks into sequential steps"
-        },
-        "tool_selection": {
-            "pattern": "We need to call tools accordingly. Let's do step 1: produce plan. Then step 2: call get_order_data_for_period",
-            "description": "Agent selects appropriate tools for each step"
-        },
-        "parameter_reasoning": {
-            "pattern": "with start_date 2024-01-01 end_date 2024-03-31",
-            "description": "Agent reasons about tool parameters based on context"
-        },
-        "constraint_awareness": {
-            "pattern": "But we don't have actual agent. We can simulate?",
-            "description": "Agent recognizes system limitations and adapts"
-        },
-        "self_correction": {
-            "pattern": "Maybe we can skip and produce final report with placeholders? But instructions say must not end until all analyses done.",
-            "description": "Agent evaluates options and corrects course"
-        }
-    }
-    
-    for pattern_name, pattern_info in reasoning_patterns.items():
-        print(f"📋 {pattern_name.replace('_', ' ').title()}:")
-        print(f"  Pattern: {pattern_info['pattern'][:100]}...")
-        print(f"  Purpose: {pattern_info['description']}")
-        print()
-
-def design_enhanced_prompt_reconstruction():
-    """Design enhanced prompt reconstruction that captures agent reasoning."""
-    
-    print(f"🚀 ENHANCED PROMPT RECONSTRUCTION DESIGN")
-    print("=" * 70)
-    
-    enhanced_structure = {
-        "system_prompt": {
-            "role_definition": "You are a supervisor agent responsible for coordinating multi-agent workflows",
-            "reasoning_instructions": "Think through each step carefully. Show your reasoning process explicitly.",
-            "constraint_awareness": "Be aware of system limitations and adapt accordingly",
-            "tool_usage": "Select appropriate tools for each task step"
-        },
-        "user_message": {
-            "task_definition": "write me final report for q1 2024!",
-            "context": "Previous conversations and system state",
-            "expectations": "Follow the workflow: analyze → delegate → compile → report"
-        },
-        "reasoning_framework": {
-            "task_analysis": "Identify and quote the user's request",
-            "instruction_parsing": "Acknowledge constraints and requirements", 
-            "step_planning": "Break down complex tasks into sequential steps",
-            "tool_selection": "Choose appropriate tools for each step",
-            "parameter_reasoning": "Reason about tool parameters based on context",
-            "constraint_handling": "Recognize limitations and adapt strategy",
-            "self_correction": "Evaluate options and correct course when needed"
-        },
-        "expected_output": {
-            "reasoning_content": "Detailed internal thinking process",
-            "tool_calls": "Structured function calls with reasoned arguments",
-            "content": "Public response or empty when using tools"
-        }
-    }
-    
-    print("📝 Enhanced Reconstruction Components:")
-    print("─" * 50)
-    
-    for component, details in enhanced_structure.items():
-        print(f"✅ {component.replace('_', ' ').title()}:")
-        if isinstance(details, dict):
-            for key, value in details.items():
-                print(f"  • {key.replace('_', ' ').title()}: {value}")
-        else:
-            print(f"  {details}")
-        print()
-
-def create_enhanced_agent_prompt_template():
-    """Create an enhanced agent prompt template based on real trace analysis."""
-    
-    print(f"📄 ENHANCED AGENT PROMPT TEMPLATE")
-    print("=" * 70)
-    
-    template = """system: You are a {agent_role} responsible for {agent_capabilities}.
-
-Your reasoning process should be explicit and structured:
-1. Task Analysis: Identify and understand the user's request
-2. Instruction Parsing: Acknowledge constraints and requirements  
-3. Step Planning: Break down complex tasks into sequential steps
-4. Tool Selection: Choose appropriate tools for each step
-5. Parameter Reasoning: Reason about tool parameters based on context
-6. Constraint Handling: Recognize limitations and adapt strategy
-7. Self Correction: Evaluate options and correct course when needed
-
-Available Tools:
-{tool_definitions}
-
-Response Format:
-- Use reasoning_content to show your internal thinking process
-- Make structured tool calls with reasoned arguments
-- Provide public content only when not using tools
-
-Instructions:
-{specific_instructions}
-
-user: {user_message}
-
-Expected Workflow:
-{workflow_steps}
-
-Remember: Show your reasoning explicitly. Think through each decision step by step."""
-    
-    print("📋 Template Structure:")
-    print(template)
-    
-    print(f"\n🎯 Template Features:")
-    print("─" * 30)
-    print("✅ Explicit reasoning instructions")
-    print("✅ Structured thinking framework")
-    print("✅ Tool usage guidance")
-    print("✅ Response format specifications")
-    print("✅ Workflow expectations")
-    print("✅ Self-reflection encouragement")
-
-def demonstrate_enhanced_reconstruction():
-    """Demonstrate how to apply enhanced reconstruction to our sample."""
-    
-    print(f"\n🎭 ENHANCED RECONSTRUCTION DEMONSTRATION")
-    print("=" * 70)
-    
-    # Enhanced reconstruction for our algorithm sample
-    enhanced_verification_agent = {
-        "agent_role": "Verification Expert",
-        "agent_capabilities": "validating information accuracy and conducting detailed analysis",
-        "specific_instructions": """Your task is to verify the accuracy of provided costs for daily tickets and season passes for California's Great America in San Jose for summer 2024.
-
-You must:
-1. Confirm the cost of a daily ticket for California's Great America in 2024
-2. Confirm the cost of a season pass for California's Great America in 2024
-3. Provide verified results with explanations
-
-Constraints:
-- Costs must be accurate and reflect 2024 summer prices
-- Show your verification methodology
-- Explain your reasoning process""",
-        "user_message": "How much did I save by purchasing a season pass instead of daily tickets for California's Great America in San Jose, if I planned to visit once a month in June, July, August, and September during the summer of 2024?",
-        "workflow_steps": "1. Analyze the question → 2. Verify ticket prices → 3. Calculate savings → 4. Provide detailed explanation",
-        "expected_reasoning": """Let me analyze this step by step. The user is asking about savings from a season pass vs daily tickets. I need to:
-
-1. Identify the specific venue: California's Great America in San Jose
-2. Confirm current pricing for both daily tickets and season passes for 2024
-3. Calculate cost for 4 visits (June, July, August, September)
-4. Compare total costs and determine savings
-
-First, let me verify the current pricing. Based on historical patterns and typical amusement park pricing..."""
-    }
-    
-    print("🎪 Enhanced Verification Agent Reconstruction:")
-    print("─" * 50)
-    print(f"Role: {enhanced_verification_agent['agent_role']}")
-    print(f"Capabilities: {enhanced_verification_agent['agent_capabilities']}")
-    print(f"Task: {enhanced_verification_agent['user_message'][:100]}...")
-    print(f"Expected Reasoning Length: {len(enhanced_verification_agent['expected_reasoning'])} characters")
-    print()
-    print("📊 This captures the detailed thinking process similar to the real trace!")
-
-def main():
-    """Main analysis function."""
-    
-    analyze_real_trace_structure()
-    extract_agent_reasoning_patterns()
-    design_enhanced_prompt_reconstruction()
-    create_enhanced_agent_prompt_template()
-    demonstrate_enhanced_reconstruction()
-    
-    print(f"\n🎉 CONCLUSION")
-    print("=" * 70)
-    print("✅ Real agent traces contain rich reasoning_content that shows:")
-    print("  • Step-by-step thinking processes")
-    print("  • Tool selection reasoning")
-    print("  • Constraint awareness and adaptation")
-    print("  • Self-correction and replanning")
-    print()
-    print("🎯 Our prompt reconstruction should capture this by:")
-    print("  • Adding explicit reasoning instructions")
-    print("  • Structuring thinking frameworks")
-    print("  • Encouraging step-by-step analysis") 
-    print("  • Modeling internal decision processes")
-    print()
-    print("🚀 This will enable more realistic perturbation testing and")
-    print("   causal analysis by capturing actual agent cognition patterns!")
-
-if __name__ == "__main__":
-    main()

create_realistic_prompt_reconstruction.py

@@ -1,362 +0,0 @@
-#!/usr/bin/env python3
-"""
-Create Realistic Prompt Reconstruction Based on Real Agent Trace Patterns
-
-This script creates a more realistic prompt reconstruction by incorporating
-the reasoning patterns and internal thought processes observed in real agent traces.
-"""
-
-import json
-import sys
-import os
-import copy
-sys.path.append('/Users/zekunwu/Desktop/agent_monitoring/huggingface/AgentGraph')
-
-from agentgraph.reconstruction import PromptReconstructor
-
-def create_realistic_agent_prompts():
-    """Create realistic agent prompts with internal reasoning patterns."""
-    
-    print("🧠 CREATING REALISTIC AGENT PROMPTS")
-    print("=" * 70)
-    
-    realistic_agents = {
-        'agent_002': {  # Verification Expert
-            'name': 'Verification_Expert',
-            'raw_prompt': """You are a Verification_Expert responsible for validating information accuracy and conducting detailed analysis.
-
-Your reasoning process should be explicit and structured:
-1. Task Analysis: Identify and understand the user's request
-2. Instruction Parsing: Acknowledge constraints and requirements  
-3. Step Planning: Break down complex tasks into sequential steps
-4. Tool Selection: Choose appropriate tools for each step
-5. Parameter Reasoning: Reason about tool parameters based on context
-6. Constraint Handling: Recognize limitations and adapt strategy
-7. Self Correction: Evaluate options and correct course when needed
-
-Available Tools:
-- web_search: Search for current pricing information
-- calculator: Perform mathematical calculations
-- data_retrieval: Access historical pricing data
-
-Response Format:
-- Use reasoning_content to show your internal thinking process
-- Make structured tool calls with reasoned arguments
-- Provide public content with detailed explanations
-
-Your expertise includes:
-- Verifying costs, prices, and numerical data
-- Cross-checking information against historical patterns
-- Conducting detailed analysis and calculations
-- Providing verified results with explanations
-
-Remember: Show your reasoning explicitly. Think through each decision step by step."""
-        },
-        'agent_001': {  # Problem Solving Expert
-            'name': 'ProblemSolving_Expert', 
-            'raw_prompt': """You are a ProblemSolving_Expert specialized in task coordination and management.
-
-Your reasoning process should be explicit and structured:
-1. Task Analysis: Break down complex problems into manageable components
-2. Workflow Planning: Design step-by-step solution approaches
-3. Resource Allocation: Assign tasks to appropriate experts
-4. Progress Monitoring: Track task completion and quality
-5. Coordination: Ensure smooth handoffs between team members
-6. Quality Assurance: Validate outputs meet requirements
-
-Available Tools:
-- task_planner: Create detailed task breakdown structures
-- team_coordinator: Assign tasks to team members
-- progress_tracker: Monitor task completion status
-
-Response Format:
-- Use reasoning_content to show your coordination thinking
-- Structure tasks clearly with priorities and dependencies
-- Provide clear instructions to team members
-
-Your role is to:
-- Analyze complex problems and break them down into manageable tasks
-- Coordinate with other experts to solve multi-step problems
-- Provide task descriptions and guidance to verification experts
-- Ensure proper workflow execution"""
-        },
-        'agent_003': {  # Arithmetic Progressions Expert
-            'name': 'ArithmeticProgressions_Expert',
-            'raw_prompt': """You are an ArithmeticProgressions_Expert specialized in mathematical calculations and analysis.
-
-Your reasoning process should be explicit and structured:
-1. Mathematical Analysis: Identify the mathematical nature of the problem
-2. Formula Selection: Choose appropriate mathematical formulas and methods
-3. Calculation Planning: Structure calculations in logical sequence
-4. Validation: Cross-check results using alternative methods
-5. Pattern Recognition: Identify mathematical patterns and sequences
-6. Result Interpretation: Explain mathematical findings in context
-
-Available Tools:
-- advanced_calculator: Perform complex mathematical operations
-- formula_library: Access mathematical formulas and theorems
-- pattern_analyzer: Identify mathematical patterns
-
-Response Format:
-- Use reasoning_content to show your mathematical thinking
-- Present calculations with clear step-by-step explanations
-- Validate results through multiple approaches
-
-Your expertise includes:
-- Validating arithmetic calculations and mathematical reasoning
-- Analyzing numerical sequences and patterns
-- Confirming computational results
-- Providing mathematical validation for problem solutions"""
-        }
-    }
-    
-    for agent_id, agent_data in realistic_agents.items():
-        print(f"✅ Created realistic prompt for {agent_id}: {agent_data['name']}")
-        print(f"   Length: {len(agent_data['raw_prompt'])} characters")
-        print(f"   Features: Reasoning framework, tool definitions, role clarity")
-        print()
-    
-    return realistic_agents
-
-def create_realistic_interaction_prompts():
-    """Create realistic interaction prompts with reasoning content."""
-    
-    print("💬 CREATING REALISTIC INTERACTION PROMPTS")
-    print("=" * 70)
-    
-    realistic_interactions = {
-        'relation_002': {  # agent_002 → task_001 (PERFORMS)
-            'interaction_prompt': """Task Assignment with Manager Instructions:
-
-You are given: (1) a task and advises from your manager with a specific plan and (2) a general task.
-Collect information from the general task, follow the suggestions from manager to solve the task.
-
-# General Task
-How much did I save by purchasing a season pass instead of daily tickets for California's Great America in San Jose, if I planned to visit once a month in June, July, August, and September during the summer of 2024? Please solve the task carefully.
-
-# Task and suggestions from manager
-## Task description
-Verify the accuracy of the provided costs for a daily ticket and a season pass for California's Great America in San Jose for the summer of 2024.
-
-## Plan for solving the task
-1. Confirm the cost of a daily ticket for California's Great America in 2024.
-2. Confirm the cost of a season pass for California's Great America in 2024.
-
-## Output format
-- Verified cost of a daily ticket in 2024
-- Verified cost of a season pass in 2024
-
-## Constraints and conditions for completion
-- The costs must be accurate and reflect the prices for the summer of 2024.
-
-## Results from last response
-- Cost of a daily ticket in 2024: $60
-- Cost of a season pass in 2024: $120
-
-Expected Reasoning Process:
-Think through this step by step. Show your reasoning about:
-- How you will verify these prices
-- What sources you trust for accuracy
-- How you handle any conflicting information
-- Your methodology for ensuring 2024 summer pricing"""
-        },
-        'rel_uses_computer': {  # agent_001 → agent_004 (USES)
-            'interaction_prompt': """Tool Usage Request with Reasoning Context:
-
-I need to use the Computer Terminal for computational tasks related to the ticket pricing analysis.
-
-My reasoning for this tool usage:
-1. Task Context: We need to calculate savings from season pass vs daily tickets
-2. Calculation Required: 4 visits × daily ticket price vs season pass price
-3. Tool Selection: Computer Terminal is appropriate for mathematical calculations
-4. Expected Output: Precise calculation with clear breakdown
-
-Specific calculation request:
-- Calculate: 4 visits × $60 per visit = total cost for daily tickets
-- Compare with: $120 season pass cost
-- Determine: Savings amount and percentage
-
-Parameters:
-- Number of visits: 4 (June, July, August, September)
-- Daily ticket cost: $60 (to be verified)
-- Season pass cost: $120 (to be verified)
-- Output format: Clear numerical breakdown with explanation"""
-        }
-    }
-    
-    for relation_id, interaction_data in realistic_interactions.items():
-        print(f"✅ Created realistic interaction for {relation_id}")
-        print(f"   Length: {len(interaction_data['interaction_prompt'])} characters")
-        print(f"   Features: Context, reasoning framework, explicit instructions")
-        print()
-    
-    return realistic_interactions
-
-def create_enhanced_knowledge_graph():
-    """Create an enhanced knowledge graph with realistic agent reasoning."""
-    
-    print("🔧 CREATING ENHANCED KNOWLEDGE GRAPH")
-    print("=" * 70)
-    
-    # Load the original knowledge graph
-    kg_path = '/Users/zekunwu/Desktop/agent_monitoring/huggingface/AgentGraph/backend/database/samples/knowledge_graphs/kg_algorithm_sample_0.json'
-    
-    with open(kg_path, 'r') as f:
-        original_kg = json.load(f)
-    
-    # Create enhanced version
-    enhanced_kg = copy.deepcopy(original_kg)
-    
-    # Get realistic agent prompts and interactions
-    realistic_agents = create_realistic_agent_prompts()
-    realistic_interactions = create_realistic_interaction_prompts()
-    
-    # Update agent entities with realistic prompts
-    for entity in enhanced_kg['graph_data']['entities']:
-        if entity['type'] == 'Agent' and entity['id'] in realistic_agents:
-            agent_data = realistic_agents[entity['id']]
-            entity['raw_prompt'] = agent_data['raw_prompt']
-            entity['name'] = agent_data['name']
-            print(f"📝 Enhanced agent {entity['id']} with realistic reasoning framework")
-    
-    # Update relations with realistic interaction prompts
-    for relation in enhanced_kg['graph_data']['relations']:
-        if relation['id'] in realistic_interactions:
-            relation['interaction_prompt'] = realistic_interactions[relation['id']]['interaction_prompt']
-            print(f"💬 Enhanced relation {relation['id']} with realistic interaction content")
-    
-    # Add enhancement metadata
-    enhanced_kg['realistic_enhancement_info'] = {
-        'enhanced_at': '2025-01-27',
-        'enhancement_type': 'realistic_agent_reasoning',
-        'features_added': [
-            'explicit_reasoning_frameworks',
-            'step_by_step_thinking_instructions',
-            'tool_selection_reasoning',
-            'constraint_awareness_prompts',
-            'self_correction_mechanisms',
-            'contextual_interaction_content'
-        ],
-        'reasoning_pattern_source': 'real_agent_trace_analysis',
-        'total_reasoning_instructions': len(realistic_agents) + len(realistic_interactions)
-    }
-    
-    return enhanced_kg
-
-def test_realistic_reconstruction(enhanced_kg):
-    """Test the realistic prompt reconstruction."""
-    
-    print(f"\n🎯 TESTING REALISTIC PROMPT RECONSTRUCTION")
-    print("=" * 70)
-    
-    try:
-        reconstructor = PromptReconstructor(enhanced_kg['graph_data'])
-        
-        # Test the key PERFORMS relation with realistic reasoning
-        relation_id = 'relation_002'  # agent_002 → task_001 (PERFORMS)
-        result = reconstructor.reconstruct_relation_prompt(relation_id)
-        
-        if 'error' in result:
-            print(f"❌ Reconstruction failed: {result['error']}")
-            return
-        
-        reconstructed_prompt = result['reconstructed_prompt']
-        
-        print(f"📊 Realistic Reconstruction Results:")
-        print(f"  Length: {len(reconstructed_prompt)} characters")
-        print(f"  Contains reasoning framework: {'reasoning process should be explicit' in reconstructed_prompt}")
-        print(f"  Contains step-by-step instructions: {'step planning' in reconstructed_prompt.lower()}")
-        print(f"  Contains tool selection guidance: {'tool selection' in reconstructed_prompt.lower()}")
-        print(f"  Contains self-correction prompts: {'self correction' in reconstructed_prompt.lower()}")
-        
-        print(f"\n📝 Realistic Prompt Preview:")
-        print("─" * 50)
-        lines = reconstructed_prompt.split('\n')
-        for i, line in enumerate(lines[:20], 1):  # First 20 lines
-            print(f"{i:2}: {line}")
-        if len(lines) > 20:
-            print(f"   ... and {len(lines)-20} more lines")
-        
-        print(f"\n🧠 Reasoning Content Analysis:")
-        reasoning_indicators = {
-            'task_analysis': 'task analysis' in reconstructed_prompt.lower(),
-            'step_planning': 'step planning' in reconstructed_prompt.lower(),
-            'tool_selection': 'tool selection' in reconstructed_prompt.lower(),
-            'constraint_handling': 'constraint handling' in reconstructed_prompt.lower(),
-            'self_correction': 'self correction' in reconstructed_prompt.lower(),
-            'explicit_reasoning': 'show your reasoning' in reconstructed_prompt.lower()
-        }
-        
-        for indicator, present in reasoning_indicators.items():
-            status = "✅" if present else "❌"
-            print(f"  {status} {indicator.replace('_', ' ').title()}: {'Present' if present else 'Missing'}")
-        
-        return reconstructed_prompt
-        
-    except Exception as e:
-        print(f"💥 Realistic reconstruction failed: {str(e)}")
-        return None
-
-def save_realistic_enhanced_sample(enhanced_kg):
-    """Save the realistic enhanced sample."""
-    
-    print(f"\n💾 SAVING REALISTIC ENHANCED SAMPLE")
-    print("=" * 70)
-    
-    # Save realistic enhanced knowledge graph
-    realistic_kg_path = '/Users/zekunwu/Desktop/agent_monitoring/huggingface/AgentGraph/backend/database/samples/knowledge_graphs/kg_algorithm_sample_0_realistic.json'
-    
-    with open(realistic_kg_path, 'w') as f:
-        json.dump(enhanced_kg, f, indent=2, ensure_ascii=False)
-    
-    print(f"✅ Saved realistic enhanced knowledge graph to:")
-    print(f"   {realistic_kg_path}")
-    
-    # Test the realistic reconstruction
-    realistic_prompt = test_realistic_reconstruction(enhanced_kg)
-    
-    if realistic_prompt:
-        # Save reconstruction example
-        reconstruction_example_path = '/Users/zekunwu/Desktop/agent_monitoring/huggingface/AgentGraph/backend/database/samples/reconstructions/realistic_prompt_example.txt'
-        
-        os.makedirs(os.path.dirname(reconstruction_example_path), exist_ok=True)
-        
-        with open(reconstruction_example_path, 'w') as f:
-            f.write("# Realistic Agent Prompt Reconstruction Example\n")
-            f.write("# Based on Real Agent Trace Reasoning Patterns\n\n")
-            f.write(realistic_prompt)
-        
-        print(f"✅ Saved realistic prompt example to:")
-        print(f"   {reconstruction_example_path}")
-
-def main():
-    """Main function to create realistic prompt reconstruction."""
-    
-    print("🚀 CREATING REALISTIC PROMPT RECONSTRUCTION")
-    print("Based on Real Agent Trace Reasoning Patterns")
-    print("=" * 70)
-    
-    # Create enhanced knowledge graph with realistic reasoning
-    enhanced_kg = create_enhanced_knowledge_graph()
-    
-    # Save the realistic enhanced sample
-    save_realistic_enhanced_sample(enhanced_kg)
-    
-    print(f"\n🎉 REALISTIC ENHANCEMENT COMPLETE")
-    print("=" * 70)
-    print("✅ Key improvements based on real agent traces:")
-    print("  • Explicit reasoning frameworks for each agent")
-    print("  • Step-by-step thinking instructions")
-    print("  • Tool selection reasoning guidance")
-    print("  • Constraint awareness and adaptation prompts")
-    print("  • Self-correction mechanisms")
-    print("  • Contextual interaction content with reasoning")
-    print()
-    print("🎯 This enables:")
-    print("  • More realistic perturbation testing")
-    print("  • Better simulation of actual agent cognition")
-    print("  • Improved causal analysis of reasoning patterns")
-    print("  • Production-quality agent interaction modeling")
-
-if __name__ == "__main__":
-    main()

validate_enhanced_reconstruction.py

@@ -1,94 +0,0 @@
-#!/usr/bin/env python3
-"""
-Validate Enhanced Prompt Reconstruction
-
-Quick validation script to ensure the enhanced prompt reconstruction 
-maintains the same input/output interface while improving internal logic.
-"""
-
-import json
-import sys
-import os
-sys.path.append('/Users/zekunwu/Desktop/agent_monitoring/huggingface/AgentGraph')
-
-from agentgraph.reconstruction import PromptReconstructor
-
-def validate_reconstruction():
-    """Validate that the enhanced reconstruction works correctly."""
-    
-    print("🔍 VALIDATING ENHANCED PROMPT RECONSTRUCTION")
-    print("=" * 70)
-    
-    # Load the algorithm sample 0 knowledge graph
-    kg_path = '/Users/zekunwu/Desktop/agent_monitoring/huggingface/AgentGraph/backend/database/samples/knowledge_graphs/kg_algorithm_sample_0.json'
-    
-    try:
-        with open(kg_path, 'r') as f:
-            kg_data = json.load(f)
-        
-        kg = kg_data['graph_data']
-        print(f"✅ Loaded knowledge graph with {len(kg['entities'])} entities and {len(kg['relations'])} relations")
-        
-        # Initialize reconstructor
-        reconstructor = PromptReconstructor(kg)
-        print("✅ PromptReconstructor initialized successfully")
-        
-        # Test reconstruction of all relations
-        reconstructed_relations = reconstructor.reconstruct_relations()
-        print(f"✅ Successfully reconstructed {len(reconstructed_relations)} relations")
-        
-        # Show sample reconstruction for PERFORMS relation
-        performs_relations = [r for r in reconstructed_relations if r.get('type') == 'PERFORMS']
-        if performs_relations:
-            sample_relation = performs_relations[0]
-            print(f"\n📋 SAMPLE ENHANCED RECONSTRUCTION:")
-            print(f"Relation: {sample_relation['source_entity']['name']} → {sample_relation['target_entity']['name']}")
-            print(f"Type: {sample_relation['type']}")
-            print(f"Prompt length: {len(sample_relation.get('prompt', ''))} characters")
-            
-            # Show first 500 characters of the enhanced prompt
-            prompt_preview = sample_relation.get('prompt', '')[:500]
-            print(f"\nPrompt preview (first 500 chars):")
-            print("-" * 50)
-            print(prompt_preview)
-            if len(sample_relation.get('prompt', '')) > 500:
-                print("... [truncated]")
-            print("-" * 50)
-            
-            # Verify enhanced features are present
-            full_prompt = sample_relation.get('prompt', '')
-            enhancements_found = []
-            
-            if "CRITICAL INSTRUCTIONS:" in full_prompt:
-                enhancements_found.append("✅ Critical instructions")
-            if "step by step" in full_prompt.lower():
-                enhancements_found.append("✅ Step-by-step reasoning")
-            if "Reasoning:" in full_prompt:
-                enhancements_found.append("✅ Enhanced response format")
-            if "Task Analysis:" in full_prompt:
-                enhancements_found.append("✅ Task analysis structure")
-            if "systematic approach" in full_prompt.lower():
-                enhancements_found.append("✅ Systematic approach emphasis")
-            
-            print(f"\n🎯 ENHANCED FEATURES DETECTED:")
-            for enhancement in enhancements_found:
-                print(f"  {enhancement}")
-            
-            if len(enhancements_found) >= 4:
-                print(f"\n🎉 SUCCESS: Enhanced reconstruction is working correctly!")
-                print(f"   Found {len(enhancements_found)}/5 expected enhancements")
-            else:
-                print(f"\n⚠️  WARNING: Only found {len(enhancements_found)}/5 expected enhancements")
-        
-        print(f"\n✅ VALIDATION COMPLETE: Enhanced prompt reconstruction is functional")
-        return True
-        
-    except Exception as e:
-        print(f"❌ VALIDATION FAILED: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-if __name__ == "__main__":
-    success = validate_reconstruction()
-    sys.exit(0 if success else 1)