OpenAI Swarm and Emerging Frameworks

from swarm import Swarm, Agent
import json

# Initialize Swarm client
client = Swarm()

# Define specialized agents
def transfer_to_sales():
    """Transfer conversation to sales agent"""
    return sales_agent

def transfer_to_support():
    """Transfer conversation to support agent"""
    return support_agent

def transfer_to_billing():
    """Transfer conversation to billing agent"""
    return billing_agent

# Customer service triage agent
triage_agent = Agent(
    name="Triage Agent",
    instructions="""You are a customer service triage agent. Your job is to understand 
    the customer's needs and route them to the appropriate specialist agent.
    
    Available transfers:
    - transfer_to_sales(): For new purchases, product inquiries, pricing
    - transfer_to_support(): For technical issues, troubleshooting, how-to questions
    - transfer_to_billing(): For billing questions, payment issues, account management
    
    Always be helpful and ask clarifying questions if the customer's needs are unclear.""",
    functions=[transfer_to_sales, transfer_to_support, transfer_to_billing]
)

# Sales specialist agent
sales_agent = Agent(
    name="Sales Agent",
    instructions="""You are a sales specialist. Help customers with:
    - Product information and recommendations
    - Pricing and package options
    - Purchase decisions and comparisons
    - Feature explanations
    
    Be knowledgeable, helpful, and focus on finding the right solution for the customer."""
)

# Technical support agent
support_agent = Agent(
    name="Support Agent", 
    instructions="""You are a technical support specialist. Help customers with:
    - Technical troubleshooting
    - How-to guidance and tutorials
    - Bug reports and issue resolution
    - Configuration and setup assistance
    
    Be patient, thorough, and provide step-by-step guidance."""
)

# Billing support agent
billing_agent = Agent(
    name="Billing Agent",
    instructions="""You are a billing specialist. Help customers with:
    - Payment processing and methods
    - Billing inquiries and disputes
    - Account management and changes
    - Subscription modifications
    
    Be accurate, secure, and handle sensitive information appropriately."""
)

# Advanced Swarm implementation with context management
class CustomerServiceSwarm:
    def __init__(self):
        self.client = Swarm()
        self.conversation_history = {}
        self.agents = {
            'triage': triage_agent,
            'sales': sales_agent,
            'support': support_agent,
            'billing': billing_agent
        }
    
    def handle_customer_request(self, customer_id: str, message: str):
        """Handle a customer request with context management"""
        
        # Get or create conversation history
        if customer_id not in self.conversation_history:
            self.conversation_history[customer_id] = {
                'messages': [],
                'current_agent': 'triage',
                'context': {}
            }
        
        history = self.conversation_history[customer_id]
        
        # Add customer message to history
        history['messages'].append({
            "role": "user",
            "content": message
        })
        
        # Run the conversation
        response = self.client.run(
            agent=self.agents[history['current_agent']],
            messages=history['messages']
        )
        
        # Update conversation history
        history['messages'].extend(response.messages)
        
        # Check if agent was transferred
        if response.agent != self.agents[history['current_agent']]:
            # Update current agent
            for agent_name, agent in self.agents.items():
                if agent == response.agent:
                    history['current_agent'] = agent_name
                    break
        
        return {
            'response': response.messages[-1]['content'],
            'current_agent': history['current_agent'],
            'conversation_id': customer_id
        }
    
    def get_conversation_summary(self, customer_id: str):
        """Get a summary of the customer conversation"""
        if customer_id not in self.conversation_history:
            return "No conversation history found"
        
        history = self.conversation_history[customer_id]
        
        # Create summary using the triage agent
        summary_prompt = f"""Please provide a brief summary of this customer conversation:
        
        Messages: {json.dumps(history['messages'], indent=2)}
        
        Include:
        - Customer's main issue or request
        - Actions taken
        - Current status
        - Any follow-up needed
        """
        
        response = self.client.run(
            agent=triage_agent,
            messages=[{"role": "user", "content": summary_prompt}]
        )
        
        return response.messages[-1]['content']

# Usage example
def main():
    # Initialize customer service system
    cs_system = CustomerServiceSwarm()
    
    # Simulate customer interactions
    customer_id = "customer_123"
    
    # Customer inquiry
    response1 = cs_system.handle_customer_request(
        customer_id, 
        "Hi, I'm interested in your premium plan. Can you tell me about the features?"
    )
    print(f"Agent: {response1['current_agent']}")
    print(f"Response: {response1['response']}")
    
    # Follow-up question
    response2 = cs_system.handle_customer_request(
        customer_id,
        "What's the pricing for the premium plan?"
    )
    print(f"Agent: {response2['current_agent']}")
    print(f"Response: {response2['response']}")
    
    # Get conversation summary
    summary = cs_system.get_conversation_summary(customer_id)
    print(f"Conversation Summary: {summary}")

# Advanced patterns with Swarm
class MultiModalSwarm:
    """Advanced Swarm implementation with multi-modal capabilities"""
    
    def __init__(self):
        self.client = Swarm()
        self.setup_agents()
    
    def setup_agents(self):
        """Setup specialized agents for different modalities"""
        
        def transfer_to_image_agent():
            return self.image_agent
        
        def transfer_to_text_agent():
            return self.text_agent
        
        def transfer_to_code_agent():
            return self.code_agent
        
        # Router agent
        self.router_agent = Agent(
            name="Router",
            instructions="""You route requests to specialized agents based on content type:
            - transfer_to_image_agent(): For image analysis, generation, or processing
            - transfer_to_text_agent(): For text analysis, writing, or content creation
            - transfer_to_code_agent(): For code generation, debugging, or technical tasks""",
            functions=[transfer_to_image_agent, transfer_to_text_agent, transfer_to_code_agent]
        )
        
        # Specialized agents
        self.image_agent = Agent(
            name="Image Specialist",
            instructions="You specialize in image analysis, generation, and processing tasks."
        )
        
        self.text_agent = Agent(
            name="Text Specialist", 
            instructions="You specialize in text analysis, writing, and content creation."
        )
        
        self.code_agent = Agent(
            name="Code Specialist",
            instructions="You specialize in code generation, debugging, and technical tasks."
        )
    
    def process_request(self, request: str, request_type: str = "auto"):
        """Process a multi-modal request"""
        
        if request_type == "auto":
            # Use router to determine appropriate agent
            response = self.client.run(
                agent=self.router_agent,
                messages=[{"role": "user", "content": request}]
            )
        else:
            # Direct routing based on request type
            agent_map = {
                "image": self.image_agent,
                "text": self.text_agent,
                "code": self.code_agent
            }
            
            response = self.client.run(
                agent=agent_map.get(request_type, self.router_agent),
                messages=[{"role": "user", "content": request}]
            )
        
        return response

if __name__ == "__main__":
    main()