Duplicate Agent¶

import asyncio
import uuid
import socket
import time
import os
from arcp import ARCPClient

async def generate_unique_agent_id():
    """Generate unique agent ID using various methods"""

    # Method 1: UUID-based
    uuid_id = f"agent-{uuid.uuid4().hex[:8]}"

    # Method 2: Hostname + timestamp
    hostname_id = f"agent-{socket.gethostname()}-{int(time.time())}"

    # Method 3: Environment-based (useful in containers)
    env_id = f"agent-{os.environ.get('POD_NAME', socket.gethostname())}-{uuid.uuid4().hex[:4]}"

    # Choose one method or combine them
    return uuid_id  # Most recommended for uniqueness

import asyncio
import atexit
import signal
import logging
from arcp import ARCPClient, ARCPError

logger = logging.getLogger(__name__)

class GracefulAgent:
    def __init__(self, base_url: str, agent_id: str):
        self.client = ARCPClient(base_url)
        self.agent_id = agent_id
        self._registered = False

    async def register(self, **agent_data):
        """Register the agent"""
        try:
            await self.client.register_agent(
                agent_id=self.agent_id,
                **agent_data
            )
            self._registered = True
            logger.info(f"Agent {self.agent_id} registered successfully")
        except Exception as e:
            logger.error(f"Failed to register agent: {e}")
            raise

    async def cleanup(self):
        """Deregister agent on shutdown"""
        if self._registered:
            try:
                # Note: Implement deregister method in the client
                # await self.client.deregister_agent(self.agent_id)
                logger.info(f"Agent {self.agent_id} deregistered")
            except ARCPError as e:
                logger.error(f"Failed to deregister: {e}")
            finally:
                await self.client.close()

# Global agent instance for cleanup
_agent_instance = None

def cleanup_handler():
    """Cleanup handler for graceful shutdown"""
    if _agent_instance:
        asyncio.run(_agent_instance.cleanup())

# Register cleanup handlers
atexit.register(cleanup_handler)
signal.signal(signal.SIGTERM, lambda s, f: cleanup_handler())
signal.signal(signal.SIGINT, lambda s, f: cleanup_handler())

import asyncio
from arcp import ARCPClient, ARCPError

async def safe_register_agent(agent_id: str, agent_data: dict):
    """Safely register agent after checking for duplicates"""
    async with ARCPClient("http://localhost:8001") as client:
        try:
            # First, try to get the agent to see if it exists
            existing_agent = await client.get_agent(agent_id)

            if existing_agent:
                print(f"Warning: Agent {agent_id} already exists")

                # Check if the existing agent is still alive
                try:
                    # You could implement a health check here
                    # For now, we'll assume we want to use a different ID
                    import uuid
                    new_agent_id = f"{agent_id}-{uuid.uuid4().hex[:4]}"
                    print(f"Using alternative ID: {new_agent_id}")
                    agent_data['agent_id'] = new_agent_id
                    agent_id = new_agent_id
                except Exception:
                    pass

        except ARCPError as e:
            # If agent is not found, that's good - we can proceed
            if "not found" in str(e).lower():
                print(f"Agent ID {agent_id} is available")
            else:
                raise

        # Proceed with registration
        try:
            result = await client.register_agent(**agent_data)
            print(f"Agent {agent_id} registered successfully")
            return result

        except Exception as e:
            print(f"Registration failed: {e}")
            raise