from langchain_core.agents import AgentExecutor, create_react_agent
from langchain_core.tools import BaseTool
from langchain_openai import ChatOpenAI

from uagents_adapter import LangchainRegisterTool

# Create your LangChain agent
llm = ChatOpenAI(model_name="gpt-4")
tools = [...]  # Your tools here
agent = create_react_agent(llm, tools)
agent_executor = AgentExecutor(agent=agent, tools=tools)

# Create uAgent register tool
register_tool = LangchainRegisterTool()

# Register the agent as a uAgent
result = register_tool.invoke({
    "agent_obj": agent_executor,
    "name": "my_langchain_agent",
    "port": 8000,
    "description": "My LangChain agent as a uAgent",
    "mailbox": True,  # Use Agentverse mailbox service
    "api_token": "YOUR_AGENTVERSE_API_TOKEN",  # Optional: for Agentverse registration
    "return_dict": True  # Return a dictionary instead of a string
})

print(f"Created uAgent '{result['agent_name']}' with address {result['agent_address']} on port {result['agent_port']}")

from crewai import Crew, Agent, Task
from uagents_adapter import CrewaiRegisterTool

# Define your CrewAI crew
agent1 = Agent(
    role="Researcher",
    goal="Research thoroughly",
    backstory="You are a skilled researcher",
    verbose=True,
    allow_delegation=False
)

task1 = Task(
    description="Research about a topic",
    agent=agent1
)

crew = Crew(
    agents=[agent1],
    tasks=[task1],
    verbose=True
)

# Create CrewAI register tool
register_tool = CrewaiRegisterTool()

# Register the crew as a uAgent
result = register_tool.invoke({
    "crew_obj": crew,
    "name": "my_crew_agent",
    "port": 8001,
    "description": "My CrewAI crew as a uAgent",
    "mailbox": True,  # Use Agentverse mailbox service
    "api_token": "YOUR_AGENTVERSE_API_TOKEN",  # Optional: for Agentverse registration
    "query_params": {
        "topic": {
            "type": "string",
            "description": "The topic to research",
            "required": True
        }
    },
    "example_query": "Research about artificial intelligence",
    "return_dict": True  # Return a dictionary instead of a string
})

print(f"Created uAgent '{result['agent_name']}' with address {result['agent_address']} on port {result['agent_port']}")

from uagents import Agent
from uagents_adapter import MCPServerAdapter
from server import mcp

# Create an MCP adapter
mcp_adapter = MCPServerAdapter(
    mcp_server=mcp,
    asi1_api_key="your_asi1_api_key",
    model="asi1-mini"     # Model options: asi1-mini, asi1-extended, asi1-fast
)

# Create a uAgent
agent = Agent()

# Add the MCP adapter protocols to the agent
for protocol in mcp_adapter.protocols:
    agent.include(protocol)

# Run the MCP adapter with the agent
mcp_adapter.run(agent)

from uagents_adapter import SingleA2AAdapter, A2AAgentConfig, a2a_servers

#Import A2A Server executor from your A2A Server code 
from brave.agent import BraveSearchAgentExecutor

def main():

    #Add details of your A2A Server
    agent_config = A2AAgentConfig(  
        name="brave_search_specialist",             #Name of A2A Server 
        description="AI Agent for web and news search using Brave Search API",       #Description of A2A Server 
        url="http://localhost:10020",               #Endpoint where the A2A Server should be running
        port=10020,                                 #port where the A2A Server should be running
        specialties=["web search", "news", "information retrieval", "local business", "site-specific lookup"],
        priority=3                                  
    )
    executor = BraveSearchAgentExecutor()
    a2a_servers([agent_config], {agent_config.name: executor})
    print(f"AgentCard manifest URL: http://localhost:{agent_config.port}/.well-known/agent.json")
    adapter = SingleA2AAdapter(
        agent_executor=executor,                #Your A2A Server Executor
        name="brave",                           #Name of uAgent 
        description="Routes queries to Brave Search AI specialists",    #Description of uAgent 
        port=8200,                              #Port where the uAgent should be running
        a2a_port=10020                          #Port where the A2A server should be running
    )
    adapter.run()

if __name__ == "__main__":
    main()

from uagents_adapter.a2a_outbound import (
    SingleA2AAdapter,
    MultiA2AAdapter,
    A2AAgentConfig,
    a2a_servers,
)

# Import your own A2A agent executors from your application
from your_project.executors import YourAgentExecutor


def run_single():
    config = A2AAgentConfig(
        name="my_specialist",
        description="Demo A2A specialist",
        url="http://localhost:10020",
        port=10020,
        specialties=["demo"],
    )
    executor = YourAgentExecutor()
    a2a_servers([config], {config.name: executor})
    adapter = SingleA2AAdapter(
        agent_executor=executor,
        name="my_uagent",
        description="Routes to a single A2A specialist",
        port=8200,
        a2a_port=10020,
    )
    adapter.run()


def run_multi():
    configs = [
        A2AAgentConfig(
            name="specialist_one",
            description="First A2A specialist",
            url="http://localhost:10020",
            port=10020,
            specialties=["one"],
            priority=2,
        ),
        A2AAgentConfig(
            name="specialist_two",
            description="Second A2A specialist",
            url="http://localhost:10022",
            port=10022,
            specialties=["two"],
        ),
    ]
    executors = {c.name: YourAgentExecutor() for c in configs}
    a2a_servers(configs, executors)
    adapter = MultiA2AAdapter(
        name="coordinator",
        description="Routes queries to multiple A2A specialists",
        llm_api_key="",  # optional; leave empty to disable LLM routing
        port=8200,
        routing_strategy="keyword_match",
    )
    for cfg in configs:
        adapter.add_agent_config(cfg)
    adapter.run()


if __name__ == "__main__":
    run_single()  # or run_multi()

from uagents_adapter import A2ARegisterTool

# Create A2A register tool
register_tool = A2ARegisterTool()

# Choose the agent you want to use from Agentverse.ai, copy its address in the config, add agent details or create a custom agent yourself and add its address in the config
# Configure your agent bridge
config = {
    "agent_address": "agent1qv4zyd9sta4f5ksyhjp900k8kenp9vczlwqvr00xmmqmj2yetdt4se9ypat",
    "name": "Finance Analysis Agent", 
    "description": "Financial analysis and market insights agent",
    "skill_tags": ["finance", "analysis", "markets", "investment"],
    "skill_examples": ["Analyze AAPL stock performance", "Compare crypto portfolios"],
    "port": 10000,  # A2A server port (default)
    "bridge_port": 9000,  # Optional: bridge port (auto-derived if not set)
    "host": "localhost"  # Default host
}

# Start the A2A bridge server
result = register_tool.invoke(config)

print(f"A2A server running on {config['host']}:{config['port']}")
print(f"Bridging to Agentverse agent: {config['agent_address']}")

class ResponseMessage(Model):
    response: str

class ResponseMessage(Model):
    response: str