from anp.openanp import RemoteAgent
from anp.authentication import DIDWbaAuthHeader

# Setup authentication (DID-WBA)
auth = DIDWbaAuthHeader(
    did_document_path="/path/to/did-doc.json",
    private_key_path="/path/to/private-key.pem",
)

# Discover agent from ad.json (fetches interface.json automatically)
agent = await RemoteAgent.discover("https://hotel.example.com/ad.json", auth)

# Inspect available methods
print(f"Agent: {agent.name}")
print(f"Methods: {agent.method_names}")  # ('search', 'book')

# Call methods - dynamic access
result = await agent.search(query="Tokyo")

# Or explicit call
result = await agent.call("search", query="Tokyo")

# Get OpenAI tools format (for LLM integration)
tools = agent.tools

from fastapi import FastAPI
from anp.openanp import anp_agent, interface, AgentConfig, Context, Information

@anp_agent(AgentConfig(
    name="Hotel Service",
    did="did:wba:example.com:hotel",
    prefix="/hotel",
    description="Hotel booking service",
))
class HotelAgent:
    # Static Information definitions
    informations = [
        Information(
            type="VideoObject",
            description="Hotel tour",
            url="https://cdn.example.com/tour.mp4",
        ),
        Information(
            type="Contact",
            description="Hotel contact info",
            mode="content",
            content={"phone": "+1-234-567"},
        ),
    ]

    @interface  # Default: content mode (embedded in interface.json)
    async def search(self, query: str) -> dict:
        """Search for hotels."""
        return {"results": [{"name": "Tokyo Hotel", "price": 100}]}

    @interface  # With Context injection
    async def search_with_session(self, query: str, ctx: Context) -> dict:
        """Search with session tracking."""
        # ctx.did - caller's DID
        # ctx.session - session for this DID
        # ctx.request - FastAPI Request
        ctx.session.set("last_query", query)
        return {"results": [...], "user": ctx.did}

    @interface(mode="link")  # Link mode: separate interface file
    async def book(self, hotel_id: str, date: str) -> dict:
        """Book a hotel room."""
        return {"booking_id": "12345", "status": "confirmed"}

app = FastAPI()
app.include_router(HotelAgent.router())

# Automatically generates:
# - GET /hotel/ad.json (with Informations)
# - GET /hotel/interface.json (content mode methods)
# - GET /hotel/interface/book.json (link mode methods)
# - POST /hotel/rpc (JSON-RPC 2.0)

from anp.openanp import anp_agent, interface, AgentConfig, Context, RemoteAgent
from anp.authentication import DIDWbaAuthHeader

@anp_agent(AgentConfig(
    name="Travel Agent",
    did="did:wba:example.com:travel",
    prefix="/travel",
))
class TravelAgent:
    def __init__(self, auth: DIDWbaAuthHeader):
        self.auth = auth

    @interface
    async def plan_trip(self, destination: str, ctx: Context) -> dict:
        """Plan a trip - I'm both server and client."""
        # Track in session
        ctx.session.set("destination", destination)

        # Discover and call hotel agent (client mode)
        hotel = await RemoteAgent.discover(
            "http://localhost:8000/hotel/ad.json",
            self.auth
        )

        hotels = await hotel.search(query=destination)
        return {
            "destination": destination,
            "hotels": hotels,
            "planner_did": ctx.did,
        }

# Create with auth for client calls
auth = DIDWbaAuthHeader(...)
travel_agent = TravelAgent(auth)
app.include_router(travel_agent.router())

# Content mode (default): embedded in single interface.json
@interface
async def search(self, query: str) -> dict:
    ...

# Link mode: separate interface file per method
@interface(mode="link")
async def book(self, hotel_id: str) -> dict:
    ...

from anp.openanp import Context

@interface
async def method(self, param: str, ctx: Context) -> dict:
    # Session management (based on caller's DID)
    ctx.session.set("key", "value")
    value = ctx.session.get("key")

    # Caller identification
    print(f"Called by: {ctx.did}")

    # Access raw request
    headers = ctx.request.headers

    return {"user": ctx.did}

ctx.session.get("key", default_value)  # Read with default
ctx.session.set("key", value)          # Write
ctx.session.clear()                     # Clear all session data

from anp.openanp import Information, information

@anp_agent(config)
class MyAgent:
    # Static definitions (class attribute)
    informations = [
        # URL mode - hosted file
        Information(
            type="Product",
            description="Room catalog",
            path="/products/rooms.json",
            file="data/rooms.json"
        ),
        # URL mode - external link
        Information(
            type="VideoObject",
            description="Hotel tour",
            url="https://cdn.hotel.com/tour.mp4"
        ),
        # Content mode - embedded in ad.json
        Information(
            type="Contact",
            description="Contact info",
            mode="content",
            content={"phone": "+1-234-567"}
        ),
    ]

    # Dynamic definitions via decorator (URL mode)
    @information(type="Product", description="Today's availability", path="/availability.json")
    def get_availability(self) -> dict:
        return {"available": self.db.get_available()}

    # Dynamic definitions via decorator (Content mode)
    @information(type="Service", description="Specials", mode="content")
    def get_specials(self) -> dict:
        return {"specials": [...]}

from fastapi import FastAPI
from anp.openanp import anp_agent, interface, AgentConfig

@anp_agent(AgentConfig(name="Hotel", did="did:wba:example.com:hotel", prefix="/hotel"))
class HotelAgent:
    @interface
    async def search(self, query: str) -> dict:
        return {"results": [...]}

    def customize_ad(self, ad: dict, base_url: str) -> dict:
        """Customize ad.json - automatically called by OpenANP.

        Args:
            ad: The auto-generated ad.json dict
            base_url: The base URL of the server

        Returns:
            The modified ad.json dict
        """
        # Add custom metadata
        ad["custom_metadata"] = {"version": "2.0.0"}

        # Add additional Informations
        if "Infomations" not in ad:
            ad["Infomations"] = []
        ad["Infomations"].append({
            "type": "FAQ",
            "description": "FAQ",
            "url": f"{base_url}/hotel/faq.json",
        })

        # Add custom support info
        ad["support"] = {"email": "support@hotel.com"}

        return ad

app = FastAPI()
agent = HotelAgent()
app.include_router(agent.router())

# Add endpoints referenced in customize_ad
@app.get("/hotel/faq.json")
async def get_faq():
    return {"faqs": [...]}

async def customize_ad(self, ad: dict, base_url: str) -> dict:
    # Async operations supported
    extra_info = await self.fetch_extra_info()
    ad["extra"] = extra_info
    return ad

# Add custom endpoints to the existing app
@app.get("/hotel/stats.json")
async def get_stats() -> JSONResponse:
    return JSONResponse({"total_products": 100})

@app.get("/hotel/health")
async def health_check() -> JSONResponse:
    return JSONResponse({"status": "healthy"})

@dataclass(frozen=True)
class RemoteAgent:
    url: str                      # AD URL
    name: str                     # Agent name
    description: str              # Agent description
    methods: tuple[Method, ...]   # Available methods

    @classmethod
    async def discover(cls, ad_url: str, auth: DIDWbaAuthHeader) -> RemoteAgent:
        """Discover agent. Raises if no methods found."""

    @property
    def method_names(self) -> tuple[str, ...]:
        """Available method names."""

    @property
    def tools(self) -> list[dict]:
        """OpenAI Tools format."""

    async def call(self, method: str, **params) -> Any:
        """Call method by name."""

    # Dynamic access: agent.search(query="...")
    def __getattr__(self, name: str) -> Callable

from anp.openanp.client import HttpError, RpcError

try:
    agent = await RemoteAgent.discover(url, auth)
    result = await agent.search(query="Tokyo")
except HttpError as e:
    print(f"HTTP {e.status}: {e} (url: {e.url})")
except RpcError as e:
    print(f"RPC {e.code}: {e} (data: {e.data})")
except ValueError as e:
    print(f"Discovery failed: {e}")