massgen 0.0.3__py3-none-any.whl

massgen/tests/test_v3_3agents.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+"""
+MassGen Example: Three Agent Coordination
+
+This example demonstrates three-agent coordination using the 
+multi-region coordination UI. Three agents with different specialties work 
+together on a question that benefits from multiple perspectives.
+
+Features:
+- Three agents with distinct specialties
+- Multi-region terminal display
+- Real coordination with voting and consensus
+- Cost-effective with gpt-4o-mini model
+
+Note: Requires OPENAI_API_KEY in environment.
+"""
+
+import asyncio
+import sys
+import os
+
+# Add project root to path
+project_root = os.path.dirname(__file__)
+sys.path.insert(0, project_root)
+
+from massgen import create_simple_agent, ResponseBackend, Orchestrator
+from massgen.frontend.coordination_ui import coordinate_with_terminal_ui
+
+
+async def three_agent_example():
+    """Demonstrate three agent coordination with multi-region UI."""
+    
+    print("🎯 MassGen: Three Agent Coordination")
+    print("=" * 50)
+
+    # Check API key
+    if not os.getenv("OPENAI_API_KEY"):
+        print("❌ OPENAI_API_KEY not found")
+        return False
+
+    print("✅ OpenAI API key found")
+
+    try:
+        # Create backend
+        backend = ResponseBackend(model="gpt-4o-mini")
+        print("✅ OpenAI backend created")
+
+        # Create three agents with different specialties
+        scientist = create_simple_agent(
+            backend=backend,
+            system_message="You are a scientist who focuses on scientific accuracy and evidence-based explanations.",
+        )
+        engineer = create_simple_agent(
+            backend=backend,
+            system_message="You are an engineer who focuses on practical applications and real-world implementation.",
+        )
+        educator = create_simple_agent(
+            backend=backend,
+            system_message="You are an educator who focuses on clear, accessible explanations for learning.",
+        )
+
+        print("✅ Created 3 agents:")
+        print("  • scientist: Scientific accuracy")
+        print("  • engineer: Practical applications")
+        print("  • educator: Clear explanations")
+
+        # Create orchestrator
+        orchestrator = Orchestrator(
+            agents={"scientist": scientist, "engineer": engineer, "educator": educator}
+        )
+        print("✅ orchestrator ready")
+
+        # Question that benefits from multiple perspectives
+        question = "How does solar energy work and why is it important?"
+        print(f"\n💬 Question: {question}")
+        print("🔄 Starting three-agent coordination...\n")
+
+        # Use coordination UI
+        result = await coordinate_with_terminal_ui(
+            orchestrator,
+            question,
+            enable_final_presentation=True,
+            logging_enabled=False,
+        )
+
+        print(f"\n✅ Three agent coordination completed!")
+
+        # Show results
+        orchestrator_status = orchestrator.get_status()
+        selected_agent = orchestrator_status.get("selected_agent")
+        vote_results = orchestrator_status.get("vote_results", {})
+
+        print(f"\n📊 Results:")
+        print(f"🏆 Selected agent: {selected_agent}")
+        if vote_results.get("vote_counts"):
+            for agent, votes in vote_results["vote_counts"].items():
+                print(f"🗳️ {agent}: {votes} vote(s)")
+
+        return result
+
+    except Exception as e:
+        print(f"❌ Failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return None
+
+
+if __name__ == "__main__":
+    result = asyncio.run(three_agent_example())
+    if result:
+        print("\n🚀 Three agent coordination successful!")
+        print("💡 Demonstrated multi-agent collaboration with diverse expertise")
+    else:
+        print("\n⚠️ Check error above")
+
+    print("\n📝 Three agent example completed!")

massgen/tests/test_v3_simple.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""
+Simple test script for MassGen basic functionality.
+Tests single agent and basic orchestrator functionality.
+"""
+
+import asyncio
+import os
+import sys
+from pathlib import Path
+
+# Add project root to path
+project_root = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from massgen.backend.response import ResponseBackend
+from massgen.chat_agent import SingleAgent
+from massgen.orchestrator import Orchestrator
+
+
+async def test_single_agent():
+    """Test basic SingleAgent functionality."""
+    print("🧪 Testing SingleAgent Basic Functionality")
+    print("-" * 50)
+
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        print("❌ OPENAI_API_KEY not found - skipping single agent test")
+        return False
+
+    try:
+        backend = ResponseBackend(api_key=api_key)
+        agent = SingleAgent(
+            backend=backend,
+            agent_id="test_agent",
+            system_message="You are a helpful assistant. Provide brief, accurate answers.",
+        )
+
+        print("📤 Testing single agent response...")
+
+        messages = [{"role": "user", "content": "What is 2+2?"}]
+        response_content = ""
+
+        async for chunk in agent.chat(messages):
+            if chunk.type == "content" and chunk.content:
+                response_content += chunk.content
+                print(chunk.content, end="", flush=True)
+            elif chunk.type == "error":
+                print(f"\n❌ Error: {chunk.error}")
+                return False
+            elif chunk.type == "done":
+                break
+
+        print(
+            f"\n✅ Single agent test completed. Response: '{response_content.strip()}'"
+        )
+        return True
+
+    except Exception as e:
+        print(f"❌ Single agent test failed: {e}")
+        return False
+
+
+async def test_orchestrator_single():
+    """Test orchestrator with single agent."""
+    print("\n🧪 Testing Orchestrator with Single Agent")
+    print("-" * 50)
+
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        print("❌ OPENAI_API_KEY not found - skipping orchestrator test")
+        return False
+
+    try:
+        backend = ResponseBackend(api_key=api_key)
+        agent = SingleAgent(
+            backend=backend,
+            agent_id="solo_agent",
+            system_message="You are a knowledgeable assistant.",
+        )
+
+        orchestrator = Orchestrator(agents={"solo": agent})
+
+        print("📤 Testing orchestrator with single agent...")
+
+        messages = [
+            {"role": "user", "content": "Explain photosynthesis in one sentence."}
+        ]
+        response_content = ""
+
+        async for chunk in orchestrator.chat(messages):
+            if chunk.type == "content" and chunk.content:
+                response_content += chunk.content
+                print(chunk.content, end="", flush=True)
+            elif chunk.type == "error":
+                print(f"\n❌ Error: {chunk.error}")
+                return False
+            elif chunk.type == "done":
+                break
+
+        print(
+            f"\n✅ Orchestrator single agent test completed. Response length: {len(response_content)} chars"
+        )
+        return True
+
+    except Exception as e:
+        print(f"❌ Orchestrator single agent test failed: {e}")
+        return False
+
+
+async def test_agent_status():
+    """Test agent status functionality."""
+    print("\n🧪 Testing Agent Status")
+    print("-" * 50)
+
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        print("❌ OPENAI_API_KEY not found - skipping status test")
+        return False
+
+    try:
+        backend = ResponseBackend(api_key=api_key)
+        agent = SingleAgent(
+            backend=backend,
+            agent_id="status_test_agent",
+            system_message="Test agent for status checking.",
+        )
+
+        # Test initial status
+        status = agent.get_status()
+        print(f"📊 Agent Status: {status}")
+
+        if status.get("agent_id") == "status_test_agent":
+            print("✅ Agent status test passed")
+            return True
+        else:
+            print("❌ Agent status test failed - incorrect ID")
+            return False
+
+    except Exception as e:
+        print(f"❌ Agent status test failed: {e}")
+        return False
+
+
+async def test_conversation_history():
+    """Test conversation history management."""
+    print("\n🧪 Testing Conversation History")
+    print("-" * 50)
+
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        print("❌ OPENAI_API_KEY not found - skipping history test")
+        return False
+
+    try:
+        backend = ResponseBackend(api_key=api_key)
+        agent = SingleAgent(
+            backend=backend,
+            agent_id="history_agent",
+            system_message="You are a test agent.",
+        )
+
+        # Initial history should contain system message
+        initial_history = agent.get_conversation_history()
+        print(f"📝 Initial history length: {len(initial_history)}")
+
+        # Add a message
+        messages = [{"role": "user", "content": "Hello"}]
+        async for chunk in agent.chat(messages):
+            if chunk.type == "done":
+                break
+
+        # Check updated history
+        updated_history = agent.get_conversation_history()
+        print(f"📝 Updated history length: {len(updated_history)}")
+
+        if len(updated_history) > len(initial_history):
+            print("✅ Conversation history test passed")
+            return True
+        else:
+            print("❌ Conversation history test failed - no history update")
+            return False
+
+    except Exception as e:
+        print(f"❌ Conversation history test failed: {e}")
+        return False
+
+
+async def main():
+    """Run all simple functionality tests."""
+    print("🚀 MassGen - Simple Functionality Test Suite")
+    print("=" * 60)
+
+    results = []
+
+    # Run all tests
+    results.append(await test_single_agent())
+    results.append(await test_orchestrator_single())
+    results.append(await test_agent_status())
+    results.append(await test_conversation_history())
+
+    # Summary
+    print("\n" + "=" * 60)
+    print("📊 Test Results:")
+    print(f"✅ Passed: {sum(results)}")
+    print(f"❌ Failed: {len(results) - sum(results)}")
+
+    if all(results):
+        print("🎉 All simple functionality tests passed!")
+        print("✅ MassGen basic functionality is working correctly")
+    else:
+        print("⚠️  Some tests failed - check API key and configuration")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

massgen/tests/test_v3_three_agents.py

@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+"""
+Test script for MassGen three-agent coordination with terminal display.
+Tests orchestrator coordination between three agents with diverse expertise.
+"""
+
+import asyncio
+import os
+import sys
+from pathlib import Path
+
+# Add project root to path
+project_root = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from massgen.backend.response import ResponseBackend
+from massgen.chat_agent import SingleAgent
+from massgen.orchestrator import Orchestrator
+from massgen.frontend.coordination_ui import CoordinationUI
+
+
+async def test_three_agents_coordination():
+    """Test three-agent coordination with diverse expertise areas."""
+    print("🚀 MassGen - Three Agents Coordination Test")
+    print("=" * 60)
+
+    # Check if API key is available
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        print("❌ OPENAI_API_KEY not found in environment variables")
+        print("⚠️  Set OPENAI_API_KEY to test three-agent coordination")
+        return False
+
+    try:
+        # Create backend
+        backend = ResponseBackend(api_key=api_key)
+
+        # Create three agents with different expertise
+        researcher = SingleAgent(
+            backend=backend,
+            agent_id="researcher",
+            system_message="You are a thorough researcher who excels at gathering comprehensive information and identifying key facts. Focus on accuracy and completeness.",
+        )
+
+        analyst = SingleAgent(
+            backend=backend,
+            agent_id="analyst",
+            system_message="You are a critical analyst who specializes in evaluating information, identifying patterns, and drawing insights. Focus on analysis and interpretation.",
+        )
+
+        communicator = SingleAgent(
+            backend=backend,
+            agent_id="communicator",
+            system_message="You are a skilled communicator who excels at synthesizing complex information into clear, engaging presentations. Focus on clarity and accessibility.",
+        )
+
+        # Create orchestrator with three agents
+        agents = {
+            "researcher": researcher,
+            "analyst": analyst,
+            "communicator": communicator,
+        }
+
+        orchestrator = Orchestrator(agents=agents)
+
+        # Create UI for coordination display
+        ui = CoordinationUI(display_type="terminal", logging_enabled=True)
+
+        print("👥 Created three-agent system:")
+        print("   🔍 Researcher - Comprehensive information gathering")
+        print("   📊 Analyst - Critical analysis and pattern recognition")
+        print("   💬 Communicator - Clear synthesis and presentation")
+        print()
+
+        # Test question that benefits from all three perspectives
+        test_question = "What are the main challenges and opportunities in developing sustainable cities, and what strategies show the most promise?"
+
+        print(f"📝 Question: {test_question}")
+        print("\n🎭 Starting three-agent coordination...")
+        print("=" * 60)
+
+        # Coordinate with UI (returns final response)
+        final_response = await ui.coordinate(orchestrator, test_question)
+
+        print("\n" + "=" * 60)
+        print("✅ Three-agent coordination completed successfully!")
+        print(f"📄 Final response length: {len(final_response)} characters")
+
+        return True
+
+    except Exception as e:
+        print(f"❌ Three-agent coordination test failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+
+async def test_three_agents_simple():
+    """Simple three-agent test without UI for basic functionality verification."""
+    print("\n🧪 Simple Three-Agent Test (No UI)")
+    print("-" * 40)
+
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        print("❌ OPENAI_API_KEY not found - skipping simple test")
+        return False
+
+    try:
+        backend = ResponseBackend(api_key=api_key)
+
+        # Create minimal agents with different roles
+        planner = SingleAgent(
+            backend=backend,
+            agent_id="planner",
+            system_message="You are a strategic planner. Focus on planning and organization.",
+        )
+
+        executor = SingleAgent(
+            backend=backend,
+            agent_id="executor",
+            system_message="You are an executor. Focus on implementation and practical steps.",
+        )
+
+        evaluator = SingleAgent(
+            backend=backend,
+            agent_id="evaluator",
+            system_message="You are an evaluator. Focus on assessment and quality control.",
+        )
+
+        orchestrator = Orchestrator(
+            agents={"planner": planner, "executor": executor, "evaluator": evaluator}
+        )
+
+        print("📤 Testing simple three-agent coordination...")
+
+        messages = [
+            {
+                "role": "user",
+                "content": "How can we improve team productivity in a remote work environment?",
+            }
+        ]
+
+        response_content = ""
+        async for chunk in orchestrator.chat(messages):
+            if chunk.type == "content" and chunk.content:
+                response_content += chunk.content
+                print(chunk.content, end="", flush=True)
+            elif chunk.type == "error":
+                print(f"\n❌ Error: {chunk.error}")
+                return False
+            elif chunk.type == "done":
+                break
+
+        print(
+            f"\n✅ Simple test completed. Response length: {len(response_content)} characters"
+        )
+        return True
+
+    except Exception as e:
+        print(f"❌ Simple three-agent test failed: {e}")
+        return False
+
+
+async def test_three_agents_consensus():
+    """Test consensus building with three agents having different viewpoints."""
+    print("\n🤝 Three-Agent Consensus Test")
+    print("-" * 40)
+
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        print("❌ OPENAI_API_KEY not found - skipping consensus test")
+        return False
+
+    try:
+        backend = ResponseBackend(api_key=api_key)
+
+        # Create agents with potentially different perspectives
+        optimist = SingleAgent(
+            backend=backend,
+            agent_id="optimist",
+            system_message="You are an optimistic viewpoint agent. Focus on opportunities and positive outcomes.",
+        )
+
+        realist = SingleAgent(
+            backend=backend,
+            agent_id="realist",
+            system_message="You are a realistic viewpoint agent. Focus on practical considerations and balanced perspectives.",
+        )
+
+        skeptic = SingleAgent(
+            backend=backend,
+            agent_id="skeptic",
+            system_message="You are a skeptical viewpoint agent. Focus on potential challenges and risks.",
+        )
+
+        orchestrator = Orchestrator(
+            agents={"optimist": optimist, "realist": realist, "skeptic": skeptic}
+        )
+
+        print("📤 Testing consensus building with diverse viewpoints...")
+
+        # Question that might generate different perspectives
+        messages = [
+            {
+                "role": "user",
+                "content": "What is the future outlook for artificial intelligence in healthcare?",
+            }
+        ]
+
+        response_content = ""
+        async for chunk in orchestrator.chat(messages):
+            if chunk.type == "content" and chunk.content:
+                response_content += chunk.content
+                print(chunk.content, end="", flush=True)
+            elif chunk.type == "error":
+                print(f"\n❌ Error: {chunk.error}")
+                return False
+            elif chunk.type == "done":
+                break
+
+        print(
+            f"\n✅ Consensus test completed. Response length: {len(response_content)} characters"
+        )
+        return True
+
+    except Exception as e:
+        print(f"❌ Consensus test failed: {e}")
+        return False
+
+
+async def main():
+    """Run three-agent coordination tests."""
+    print("🚀 MassGen - Three Agents Test Suite")
+    print("=" * 60)
+
+    results = []
+
+    # Run simple test first
+    results.append(await test_three_agents_simple())
+
+    # Run consensus test
+    if results[0]:
+        results.append(await test_three_agents_consensus())
+    else:
+        print("⚠️  Skipping consensus test due to simple test failure")
+        results.append(False)
+
+    # Run full coordination test (most complex)
+    if sum(results) >= 1:  # Run if at least one previous test passes
+        results.append(await test_three_agents_coordination())
+    else:
+        print("⚠️  Skipping full coordination test due to previous failures")
+        results.append(False)
+
+    # Summary
+    print("\n" + "=" * 60)
+    print("📊 Test Results:")
+    print(f"✅ Passed: {sum(results)}")
+    print(f"❌ Failed: {len(results) - sum(results)}")
+
+    if all(results):
+        print("🎉 All three-agent tests passed!")
+        print("✅ Three-agent coordination is working correctly")
+    elif sum(results) >= 2:
+        print("✅ Most three-agent tests passed - system is functional")
+    else:
+        print("⚠️  Multiple tests failed - check API key and network connection")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())