+----------------+        +----------------+        +-----------------+
|  Frontend /   |  HTTP  |  Agent Service |  RPC   |  Gig‑Platform   |
|  Trigger (e.g.|------->| (LLM Chain)    |------->|  API (Upwork,   |
|  Slack, Web)  |        +----------------+        |   Fiverr…)      |
+----------------+                                         ^
        |                                                    |
        |  x402 payment receipt (USDC on Base)              |
        v                                                    |
+----------------+        +----------------+        +-----------------+
|  Payment Ledger|<------|  x402 Handler  |<------|  Escrow / Wallet|
+----------------+        +----------------+        +-----------------+

# agent/llm_chain.py
from langchain import OpenAI, LLMChain, PromptTemplate
from typing import Dict

# Adjust temperature for determinism; lower = more repeatable specs.
llm = OpenAI(temperature=0.2, model_name="gpt-4o-mini")

spec_template = """
You are a helpful assistant that converts a user request into a JSON spec for a freelance gig.
Only output valid JSON, no extra text.

User request: "{request}"
Fields to include:
- title: short, descriptive title (<= 80 chars)
- description: detailed description (<= 500 chars)
- skills: list of required skill strings
- budget_usd: number (optional, if user gave a budget)
- deadline_iso: ISO‑8601 timestamp (optional)

JSON:
"""
prompt = PromptTemplate(input_variables=["request"], template=spec_template)
spec_chain = LLMChain(llm=llm, prompt=prompt)

def build_spec(user_request: str) -> Dict:
    """Run the chain and coerce the output to a dict."""
    raw = spec_chain.run(request=user_request)
    # LangChain may wrap the JSON in markdown fences; strip them.
    cleaned = raw.strip().strip("```

json").strip("

```")
    try:
        return json.loads(cleaned)
    except json.JSONDecodeError as e:
        raise ValueError(f"LLM returned invalid JSON: {cleaned}") from e

# agent/gig_adapter.py
import httpx
from typing import Any, Dict

BASE_URLS = {
    "upwork": "https://www.upwork.com/api/v1",
    "fiverr": "https://www.fiverr.com/api/v2",
}

class GigAdapter:
    def __init__(self, platform: str, token: str):
        if platform not in BASE_URLS:
            raise ValueError(f"Unsupported platform: {platform}")
        self.base = BASE_URLS[platform]
        self.client = httpx.AsyncClient(
            base_url=self.base,
            headers={"Authorization": f"Bearer {token}"},
            timeout=httpx.Timeout(10.0, read=30.0),
        )

    async def create_gig(self, spec: Dict) -> Dict[str, Any]:
        """
        Platform‑specific payload mapping lives here.
        For demonstration we assume a generic shape:
        {
            "title": str,
            "description": str,
            "skills": List[str],
            "budget": {"amount": float, "currency": "USD"},
            "deadline": str   # ISO‑8601
        }
        """
        payload = {
            "title": spec.get("title", ""),
            "description": spec.get("description", ""),
            "skills": spec.get("skills", []),
            "budget": {
                "amount": spec.get("budget_usd", 0),
                "currency": "USD",
            },
        }
        if spec.get("deadline_iso"):
            payload["deadline"] = spec["deadline_iso"]

        resp = await self.client.post("/jobs", json=payload)
        if resp.status_code >= 400:
            # Bubbles up a clean error for the agent layer.
            raise httpx.HTTPStatusError(
                f"Gig platform error {resp.status_code}",
                request=resp.request,
                response=resp,
            )
        return resp.json()

# agent/x402_handler.py
from fastapi import Header, HTTPException, Request, Response
from x402 import verify_payment, PaymentRequired
import os

# Set your x402 provider’s public key (or use the default testnet).
X402_PUBLIC_KEY = os.getenv("X402_PUBLIC_KEY", "")

async def payment_middleware(request: Request, call_next):
    """
    FastAPI middleware that rejects requests without a valid x402 payment.
    The client must include the header: `X402-Payment: <signed receipt>`
    """
    receipt = request.headers.get("x402-payment")
    if not receipt:
        raise PaymentRequired(
            amount=0.01,  # minimum fee in USDC
            asset="USDC",
            network="base",
            payto="0xYourAgentWalletAddress",
        )

    try:
        await verify_payment(
            receipt=receipt,
            payload=await request.body(),
            public_key=X402_PUBLIC_KEY,
        )
    except Exception as exc:
        raise HTTPException(status_code=402, detail=str(exc))

    # Payment ok → continue to endpoint
    response: Response = await call_next(request)
    return response

# main.py
from fastapi import FastAPI
from .x402_handler import payment_middleware
from .llm_chain import build_spec
from .gig_adapter import GigAdapter

app = FastAPI()
app.middleware("http")(payment_middleware)

@app.post("/run")
async def run_agent(request: Dict):
    user_req = request.get("prompt")
    if not user_req:
        raise HTTPException(status_code=400, detail="Missing prompt")

    spec = build_spec(user_req)

    # Choose platform based on a simple heuristic or user input.
    adapter = GigAdapter(platform="upwork", token=os.getenv("UPWORK_TOKEN"))
    gig_resp = await adapter.create_gig(spec)

    return {"gig_id": gig_resp.get("id"), "spec": spec}