import asyncio, httpx, os
from eth_account import Account
from x402 import x402Client
from x402.http import x402HTTPClient
from x402.mechanisms.evm import EthAccountSigner
from x402.mechanisms.evm.exact.register import register_exact_evm_client

GATEWAY = "https://render.mirrorstage.ai"

async def create_session(face_path, output_url=""):
    # Set up x402 client with your EVM wallet
    account = Account.from_key(os.environ["EVM_PRIVATE_KEY"])
    client = x402Client()
    register_exact_evm_client(client, EthAccountSigner(account))
    http_client = x402HTTPClient(client)

    async with httpx.AsyncClient() as http:
        # Step 1: POST without payment — returns 402
        files = {"reference_image": (face_path, open(face_path, "rb"), "image/png")}
        data = {"output_url": output_url, "duration_minutes": "15", "accept_tos": "true"}
        resp = await http.post(f"{GATEWAY}/v1/sessions", files=files, data=data)

        if resp.status_code == 402:
            # Step 2: Sign the USDC payment
            payment_headers, _ = await http_client.handle_402_response(
                headers=dict(resp.headers), body=resp.content)

            # Step 3: Retry with payment header
            files = {"reference_image": (face_path, open(face_path, "rb"), "image/png")}
            resp = await http.post(f"{GATEWAY}/v1/sessions",
                files=files, data=data, headers=payment_headers)

        return resp.json()  # session_id, token, websocket_url, etc.

# For Solana instead of EVM:
pip install 'x402[svm]'

# Then replace the wallet setup:
from solders.keypair import Keypair
from x402.mechanisms.svm.signers import KeypairSigner
from x402.mechanisms.svm.exact.register import register_exact_svm_client

keypair = Keypair.from_base58_string(os.environ["SOLANA_PRIVATE_KEY"])
client = x402Client()
register_exact_svm_client(client, KeypairSigner(keypair))
# Everything else is the same — the SDK picks the right chain

import asyncio, httpx, json, websockets

API = "https://render.mirrorstage.ai"
FACE = "face.jpg"
OUTPUT_URL = ""  # omit to use the gateway's configured LiveKit URL
XI_KEY = "your-elevenlabs-key"
XI_VOICE = "your-voice-id"

async def speak(ws, text):
    """Convert agent text to speech and stream to the avatar."""
    import requests
    audio = requests.post(
        f"https://api.elevenlabs.io/v1/text-to-speech/{XI_VOICE}?output_format=pcm_16000",
        headers={"xi-api-key": XI_KEY, "Content-Type": "application/json"},
        json={"text": text, "model_id": "eleven_turbo_v2_5"},
    ).content
    # Stream PCM in 100ms chunks — GPU renders each frame as it arrives
    for i in range(0, len(audio), 3200):
        await ws.send(audio[i:i+3200])
        await asyncio.sleep(0.1)
    await ws.send(json.dumps({"type": "speak_done"}))

async def main():
    # 1. Create session (x402 payment — see Getting Started)
    async with httpx.AsyncClient(timeout=30) as c:
        r = await c.post(f"{API}/v1/sessions",
            files={"reference_image": open(FACE, "rb")},
            data={"output_url": OUTPUT_URL, "accept_tos": "true"})
        s = r.json()

    # 2. Wait for GPU to be ready
    async with httpx.AsyncClient(timeout=15) as c:
        while True:
            r = await c.get(f"{API}/v1/sessions/{s['session_id']}",
                headers={"Authorization": f"Bearer {s['token']}"})
            if r.json()["status"] == "active": break
            await asyncio.sleep(5)

    # 3. Agent loop — each response becomes a spoken utterance
    async with websockets.connect(f"{s['websocket_url']}?token={s['token']}", ping_interval=None) as ws:
        agent_responses = [
            "Welcome to the stream. I'm your AI host.",
            "Let me tell you about what we're building today.",
            "If you have questions, drop them in the chat.",
        ]
        for text in agent_responses:
            await speak(ws, text)

asyncio.run(main())

import asyncio, httpx, json, websockets

API = "https://render.mirrorstage.ai"
FACE = "face.jpg"
OUTPUT_URL = ""  # omit to use the gateway's configured LiveKit URL
FISH_KEY = "your-fish-audio-key"
FISH_VOICE = "your-voice-model-id"

async def speak(ws, text):
    """Convert agent text to speech via Fish Audio and stream to the avatar."""
    import requests
    audio = requests.post(
        "https://api.fish.audio/v1/tts",
        headers={"Authorization": f"Bearer {FISH_KEY}", "Content-Type": "application/json"},
        json={"text": text, "reference_id": FISH_VOICE, "format": "mp3"},
    ).content
    # Send MP3 as one frame — server auto-detects and decodes
    await ws.send(audio)
    await ws.send(json.dumps({"type": "speak_done"}))

async def main():
    # 1. Create session (x402 payment — see Getting Started)
    async with httpx.AsyncClient(timeout=30) as c:
        r = await c.post(f"{API}/v1/sessions",
            files={"reference_image": open(FACE, "rb")},
            data={"output_url": OUTPUT_URL, "accept_tos": "true"})
        s = r.json()

    # 2. Wait for GPU to be ready
    async with httpx.AsyncClient(timeout=15) as c:
        while True:
            r = await c.get(f"{API}/v1/sessions/{s['session_id']}",
                headers={"Authorization": f"Bearer {s['token']}"})
            if r.json()["status"] == "active": break
            await asyncio.sleep(5)

    # 3. Agent loop
    async with websockets.connect(f"{s['websocket_url']}?token={s['token']}", ping_interval=None) as ws:
        agent_responses = [
            "Hey everyone, welcome to the stream.",
            "Today we're going to talk about autonomous agents.",
        ]
        for text in agent_responses:
            await speak(ws, text)

asyncio.run(main())