AI Agent Integration

import anthropic

client = anthropic.Anthropic()

# Register LimitGuard as an MCP server
# Claude will call check_entity_trust automatically when it needs to verify an entity
response = client.beta.messages.create(
    model="claude-opus-4-6",
    max_tokens=1024,
    mcp_servers=[
        {
            "type": "url",
            "url": "https://api.limitguard.ai/mcp",
            "name": "limitguard",
            "authorization_token": "lg_live_xxxxxxxxxxxxxxxxxxxx",
        }
    ],
    messages=[
        {
            "role": "user",
            "content": (
                "I need to pay invoice #INV-2024-447 from Acme Corp BV "
                "(KVK: 12345678, NL). Should I proceed?"
            ),
        }
    ],
    betas=["mcp-client-2025-04-04"],
)

print(response.content)
# Claude calls check_entity_trust internally, interprets the score,
# and returns a recommendation with evidence.

import OpenAI from "openai";

const client = new OpenAI();

// Define LimitGuard tools from the MCP manifest
const tools = [
  {
    type: "function",
    function: {
      name: "check_entity_trust",
      description:
        "Verify the trustworthiness of a business entity before transacting. " +
        "Returns a 0-100 trust score and recommendation.",
      parameters: {
        type: "object",
        properties: {
          entity_name: { type: "string", description: "Legal business name" },
          country: { type: "string", description: "ISO 3166-1 alpha-2 country code" },
          kvk_number: { type: "string", description: "Dutch KVK registration number (optional)" },
          domain: { type: "string", description: "Company domain (optional)" },
          vat_number: { type: "string", description: "EU VAT number (optional)" },
        },
        required: ["entity_name", "country"],
      },
    },
  },
];

// Tool execution handler
async function executeTool(name, args) {
  if (name === "check_entity_trust") {
    const response = await fetch("https://api.limitguard.ai/v1/entity/check", {
      method: "POST",
      headers: {
        "X-API-Key": process.env.LIMITGUARD_API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify(args),
    });
    return response.json();
  }
}

// Agentic loop
const messages = [
  {
    role: "user",
    content:
      "Should I pay invoice #INV-2024-447 from Acme Corp BV (KVK: 12345678, NL)?",
  },
];

let response = await client.chat.completions.create({
  model: "gpt-4o",
  messages,
  tools,
});

// Handle tool calls
while (response.choices[0].finish_reason === "tool_calls") {
  const toolCall = response.choices[0].message.tool_calls[0];
  const result = await executeTool(
    toolCall.function.name,
    JSON.parse(toolCall.function.arguments)
  );

  messages.push(response.choices[0].message);
  messages.push({
    role: "tool",
    tool_call_id: toolCall.id,
    content: JSON.stringify(result),
  });

  response = await client.chat.completions.create({
    model: "gpt-4o",
    messages,
    tools,
  });
}

console.log(response.choices[0].message.content);

import httpx

class LimitGuardA2AClient:
    """A2A client for LimitGuard trust verification."""

    AGENT_CARD_URL = "https://api.limitguard.ai/.well-known/agent.json"
    BASE_URL = "https://api.limitguard.ai"

    def __init__(self, api_key: str):
        self.api_key = api_key
        self._card = None

    def discover(self) -> dict:
        """Fetch and cache the agent card."""
        if self._card is None:
            self._card = httpx.get(self.AGENT_CARD_URL).json()
        return self._card

    def get_skill(self, skill_id: str) -> dict | None:
        """Look up a skill by ID from the agent card."""
        card = self.discover()
        return next(
            (s for s in card["skills"] if s["id"] == skill_id),
            None,
        )

    def invoke(self, skill_id: str, payload: dict) -> dict:
        """Invoke a LimitGuard skill via A2A."""
        skill = self.get_skill(skill_id)
        if skill is None:
            raise ValueError(f"Skill '{skill_id}' not found in agent card")

        # Map skill IDs to LimitGuard endpoints
        endpoint_map = {
            "entity_trust_check": "/v1/entity/check",
            "risk_score": "/v1/risk/score",
            "wallet_screening": "/v1/wallet/screen",
        }

        endpoint = endpoint_map.get(skill_id)
        if endpoint is None:
            raise ValueError(f"No endpoint mapped for skill '{skill_id}'")

        response = httpx.post(
            f"{self.BASE_URL}{endpoint}",
            headers={"X-API-Key": self.api_key, "Content-Type": "application/json"},
            json=payload,
            timeout=10.0,
        )
        response.raise_for_status()
        return response.json()


# Usage in an orchestrator agent
client = LimitGuardA2AClient(api_key="lg_live_xxxxxxxxxxxxxxxxxxxx")

# Discover what LimitGuard can do
card = client.discover()
print(f"Available skills: {[s['id'] for s in card['skills']]}")
# Available skills: ['entity_trust_check', 'risk_score', 'wallet_screening']

# Invoke entity trust check
result = client.invoke(
    "entity_trust_check",
    {"entity_name": "Acme Corp BV", "country": "NL", "kvk_number": "12345678"},
)
print(f"Trust score: {result['trust_score']} — {result['recommendation']}")

class LimitGuardA2AClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = "https://api.limitguard.ai";
    this._card = null;
  }

  async discover() {
    if (!this._card) {
      const res = await fetch(`${this.baseUrl}/.well-known/agent.json`);
      this._card = await res.json();
    }
    return this._card;
  }

  async getSkill(skillId) {
    const card = await this.discover();
    return card.skills.find((s) => s.id === skillId) ?? null;
  }

  async invoke(skillId, payload) {
    const skill = await this.getSkill(skillId);
    if (!skill) throw new Error(`Skill '${skillId}' not found in agent card`);

    const endpointMap = {
      entity_trust_check: "/v1/entity/check",
      risk_score: "/v1/risk/score",
      wallet_screening: "/v1/wallet/screen",
    };

    const endpoint = endpointMap[skillId];
    if (!endpoint) throw new Error(`No endpoint mapped for skill '${skillId}'`);

    const res = await fetch(`${this.baseUrl}${endpoint}`, {
      method: "POST",
      headers: {
        "X-API-Key": this.apiKey,
        "Content-Type": "application/json",
      },
      body: JSON.stringify(payload),
    });

    if (!res.ok) throw new Error(`LimitGuard error: ${res.status}`);
    return res.json();
  }
}

// Usage
const client = new LimitGuardA2AClient("lg_live_xxxxxxxxxxxxxxxxxxxx");

const card = await client.discover();
console.log("Skills:", card.skills.map((s) => s.id));

const result = await client.invoke("entity_trust_check", {
  entity_name: "Acme Corp BV",
  country: "NL",
  kvk_number: "12345678",
});
console.log(`Trust score: ${result.trust_score} — ${result.recommendation}`);

import base64
import json
import secrets
import time
import httpx
from eth_account import Account
from eth_account.messages import encode_typed_data

USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
CHAIN_ID = "eip155:8453"

def build_x402_payment(
    amount_usdc: int,    # in 6-decimal units (50000 = $0.05)
    sender_key: str,     # agent wallet private key
    recipient: str,      # facilitator address from 402 response
) -> str:
    sender = Account.from_key(sender_key).address
    chain_num = int(CHAIN_ID.split(":")[1])  # 8453
    nonce = "0x" + secrets.token_hex(32)
    now = int(time.time())

    domain = {
        "name": "USD Coin",
        "version": "2",
        "chainId": chain_num,
        "verifyingContract": USDC_BASE,
    }
    types = {
        "EIP712Domain": [
            {"name": "name", "type": "string"},
            {"name": "version", "type": "string"},
            {"name": "chainId", "type": "uint256"},
            {"name": "verifyingContract", "type": "address"},
        ],
        "TransferWithAuthorization": [
            {"name": "from", "type": "address"},
            {"name": "to", "type": "address"},
            {"name": "value", "type": "uint256"},
            {"name": "validAfter", "type": "uint256"},
            {"name": "validBefore", "type": "uint256"},
            {"name": "nonce", "type": "bytes32"},
        ],
    }
    message = {
        "from": sender,
        "to": recipient,
        "value": amount_usdc,
        "validAfter": now - 10,
        "validBefore": now + 300,
        "nonce": bytes.fromhex(nonce[2:]),
    }

    signable = encode_typed_data(domain, types, "TransferWithAuthorization", message)
    signed = Account.sign_message(signable, private_key=sender_key)

    payload = {
        "chainId": CHAIN_ID,
        "amount": str(amount_usdc),
        "sender": sender,
        "recipient": recipient,
        "nonce": nonce,
        "signature": signed.signature.hex(),
        "validAfter": now - 10,
        "validBefore": now + 300,
    }
    return base64.b64encode(json.dumps(payload).encode()).decode()


def verify_entity_x402(
    entity_name: str,
    country: str,
    sender_key: str,
    quality: str = "fresh",  # cached | fresh | enhanced
) -> dict:
    tier_prices = {"cached": 10_000, "fresh": 50_000, "enhanced": 150_000}
    amount = tier_prices[quality]

    # Step 1: Probe to get facilitator address
    probe = httpx.post(
        "https://api.limitguard.ai/v1/entity/check",
        headers={"X-Response-Quality": quality, "Content-Type": "application/json"},
        json={"entity_name": entity_name, "country": country},
    )
    assert probe.status_code == 402, f"Expected 402, got {probe.status_code}"
    facilitator = probe.json()["accepts"][0]["recipient"]

    # Step 2: Build payment and call
    x_payment = build_x402_payment(amount, sender_key, facilitator)

    response = httpx.post(
        "https://api.limitguard.ai/v1/entity/check",
        headers={
            "X-PAYMENT": x_payment,
            "X-Response-Quality": quality,
            "Content-Type": "application/json",
        },
        json={"entity_name": entity_name, "country": country},
        timeout=15.0,
    )
    response.raise_for_status()
    return response.json()


# Usage
result = verify_entity_x402(
    entity_name="Acme Corp BV",
    country="NL",
    sender_key="0xYOUR_AGENT_WALLET_PRIVATE_KEY",
    quality="fresh",
)
print(f"Trust score: {result['trust_score']} — {result['recommendation']}")

import { ethers } from "ethers";

const USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
const CHAIN_ID = "eip155:8453";

async function buildX402Payment(amountUsdc, signer, recipient) {
  const chainNum = parseInt(CHAIN_ID.split(":")[1]);
  const nonce =
    "0x" +
    [...crypto.getRandomValues(new Uint8Array(32))]
      .map((b) => b.toString(16).padStart(2, "0"))
      .join("");
  const now = Math.floor(Date.now() / 1000);

  const domain = {
    name: "USD Coin",
    version: "2",
    chainId: chainNum,
    verifyingContract: USDC_BASE,
  };
  const types = {
    TransferWithAuthorization: [
      { name: "from", type: "address" },
      { name: "to", type: "address" },
      { name: "value", type: "uint256" },
      { name: "validAfter", type: "uint256" },
      { name: "validBefore", type: "uint256" },
      { name: "nonce", type: "bytes32" },
    ],
  };
  const message = {
    from: signer.address,
    to: recipient,
    value: amountUsdc,
    validAfter: now - 10,
    validBefore: now + 300,
    nonce,
  };

  const signature = await signer.signTypedData(domain, types, message);

  return btoa(
    JSON.stringify({
      chainId: CHAIN_ID,
      amount: String(amountUsdc),
      sender: signer.address,
      recipient,
      nonce,
      signature,
      validAfter: now - 10,
      validBefore: now + 300,
    })
  );
}

async function verifyEntityX402(entityName, country, signer, quality = "fresh") {
  const tierPrices = { cached: 10_000, fresh: 50_000, enhanced: 150_000 };
  const amount = tierPrices[quality];

  // Step 1: Probe to get facilitator address
  const probe = await fetch("https://api.limitguard.ai/v1/entity/check", {
    method: "POST",
    headers: {
      "X-Response-Quality": quality,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ entity_name: entityName, country }),
  });

  if (probe.status !== 402) throw new Error(`Expected 402, got ${probe.status}`);
  const { accepts } = await probe.json();
  const facilitator = accepts[0].recipient;

  // Step 2: Build payment and call
  const xPayment = await buildX402Payment(amount, signer, facilitator);

  const response = await fetch("https://api.limitguard.ai/v1/entity/check", {
    method: "POST",
    headers: {
      "X-PAYMENT": xPayment,
      "X-Response-Quality": quality,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ entity_name: entityName, country }),
  });

  if (!response.ok) throw new Error(`LimitGuard error: ${response.status}`);
  return response.json();
}

// Usage
const provider = new ethers.JsonRpcProvider("https://mainnet.base.org");
const signer = new ethers.Wallet(process.env.AGENT_PRIVATE_KEY, provider);

const result = await verifyEntityX402("Acme Corp BV", "NL", signer, "fresh");
console.log(`Trust score: ${result.trust_score} — ${result.recommendation}`);

import base64
import json
import os
import secrets
import time
from dataclasses import dataclass
from enum import Enum

import httpx
from eth_account import Account
from eth_account.messages import encode_typed_data


class TrustDecision(Enum):
    PROCEED = "proceed"
    REVIEW = "review"
    ENHANCED_DUE_DILIGENCE = "enhanced_due_diligence"
    BLOCK = "block"


@dataclass
class TrustResult:
    score: int
    level: str
    decision: TrustDecision
    cluster: str
    sources_checked: list[str]
    processing_ms: int
    paid_usdc: float


class TrustGatedAgent:
    """
    An autonomous payment agent that verifies counterparty trust
    before executing transactions — no human in the loop.
    """

    DISCOVERY_URL = "https://api.limitguard.ai/.well-known/x402.json"
    BASE_URL = "https://api.limitguard.ai"
    USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
    CHAIN_ID = "eip155:8453"

    def __init__(self, wallet_private_key: str):
        self.wallet = Account.from_key(wallet_private_key)
        self._discovery_cache: dict | None = None

    # ------------------------------------------------------------------ #
    # Discovery                                                            #
    # ------------------------------------------------------------------ #

    def discover(self) -> dict:
        """Fetch and cache the x402 service listing."""
        if self._discovery_cache is None:
            response = httpx.get(self.DISCOVERY_URL, timeout=5.0)
            response.raise_for_status()
            self._discovery_cache = response.json()
        return self._discovery_cache

    def get_price(self, endpoint: str, quality: str = "fresh") -> int:
        """Return price in USDC 6-decimal units for an endpoint + quality tier."""
        listing = self.discover()
        entry = next(
            (e for e in listing["endpoints"] if e["path"] == endpoint), None
        )
        if entry is None:
            raise ValueError(f"Endpoint {endpoint} not in discovery listing")
        tiers = entry.get("quality_tiers", {})
        price_str = tiers.get(quality) or entry.get("price_usdc", "0.05")
        return int(float(price_str) * 1_000_000)

    # ------------------------------------------------------------------ #
    # Payment                                                              #
    # ------------------------------------------------------------------ #

    def _get_facilitator(self, endpoint: str, payload: dict) -> str:
        """Probe an endpoint to get the current facilitator address."""
        probe = httpx.post(
            f"{self.BASE_URL}{endpoint}",
            headers={"Content-Type": "application/json"},
            json=payload,
            timeout=10.0,
        )
        if probe.status_code != 402:
            raise RuntimeError(f"Expected 402 probe, got {probe.status_code}")
        accepts = probe.json()["accepts"]
        # Prefer Base chain
        for option in accepts:
            if option["chainId"] == self.CHAIN_ID:
                return option["recipient"]
        return accepts[0]["recipient"]

    def _build_payment(self, amount: int, recipient: str) -> str:
        """Build an EIP-3009 x402 payment header."""
        chain_num = int(self.CHAIN_ID.split(":")[1])
        nonce = "0x" + secrets.token_hex(32)
        now = int(time.time())

        domain = {
            "name": "USD Coin",
            "version": "2",
            "chainId": chain_num,
            "verifyingContract": self.USDC_BASE,
        }
        types = {
            "EIP712Domain": [
                {"name": "name", "type": "string"},
                {"name": "version", "type": "string"},
                {"name": "chainId", "type": "uint256"},
                {"name": "verifyingContract", "type": "address"},
            ],
            "TransferWithAuthorization": [
                {"name": "from", "type": "address"},
                {"name": "to", "type": "address"},
                {"name": "value", "type": "uint256"},
                {"name": "validAfter", "type": "uint256"},
                {"name": "validBefore", "type": "uint256"},
                {"name": "nonce", "type": "bytes32"},
            ],
        }
        message = {
            "from": self.wallet.address,
            "to": recipient,
            "value": amount,
            "validAfter": now - 10,
            "validBefore": now + 300,
            "nonce": bytes.fromhex(nonce[2:]),
        }

        signable = encode_typed_data(
            domain, types, "TransferWithAuthorization", message
        )
        signed = Account.sign_message(signable, private_key=self.wallet.key)

        payload = {
            "chainId": self.CHAIN_ID,
            "amount": str(amount),
            "sender": self.wallet.address,
            "recipient": recipient,
            "nonce": nonce,
            "signature": signed.signature.hex(),
            "validAfter": now - 10,
            "validBefore": now + 300,
        }
        return base64.b64encode(json.dumps(payload).encode()).decode()

    def _call(self, endpoint: str, payload: dict, quality: str) -> dict:
        """Make a paid API call."""
        amount = self.get_price(endpoint, quality)
        facilitator = self._get_facilitator(endpoint, payload)
        x_payment = self._build_payment(amount, facilitator)

        response = httpx.post(
            f"{self.BASE_URL}{endpoint}",
            headers={
                "X-PAYMENT": x_payment,
                "X-Response-Quality": quality,
                "Content-Type": "application/json",
            },
            json=payload,
            timeout=15.0,
        )
        response.raise_for_status()
        return response.json()

    # ------------------------------------------------------------------ #
    # Trust verification logic                                             #
    # ------------------------------------------------------------------ #

    def _score_to_decision(self, score: int) -> TrustDecision:
        if score >= 80:
            return TrustDecision.PROCEED
        elif score >= 60:
            return TrustDecision.REVIEW
        elif score >= 40:
            return TrustDecision.ENHANCED_DUE_DILIGENCE
        else:
            return TrustDecision.BLOCK

    def verify(self, entity_name: str, country: str, **kwargs) -> TrustResult:
        """
        Verify an entity using a two-pass strategy:
        1. Cheap risk score pre-screen
        2. Full entity check only if pre-screen passes
        """
        payload = {"entity_name": entity_name, "country": country, **kwargs}
        total_paid = 0.0

        # Pass 1: Fast pre-screen ($0.01)
        risk_data = self._call("/v1/risk/score", payload, quality="cached")
        total_paid += 0.01
        pre_score = risk_data.get("risk_score", 50)

        if pre_score > 80:
            # High risk — block immediately without paying for full check
            return TrustResult(
                score=100 - pre_score,
                level="high_risk",
                decision=TrustDecision.BLOCK,
                cluster="unknown",
                sources_checked=risk_data.get("sources_checked", []),
                processing_ms=risk_data.get("processing_time_ms", 0),
                paid_usdc=total_paid,
            )

        # Pass 2: Full entity check ($0.05 fresh)
        trust_data = self._call("/v1/entity/check", payload, quality="fresh")
        total_paid += 0.05

        trust_score = trust_data["trust_score"]
        decision = self._score_to_decision(trust_score)

        return TrustResult(
            score=trust_score,
            level=trust_data["trust_level"],
            decision=decision,
            cluster=trust_data.get("cluster", "unknown"),
            sources_checked=trust_data.get("sources_checked", []),
            processing_ms=trust_data.get("processing_time_ms", 0),
            paid_usdc=total_paid,
        )

    def should_pay_invoice(
        self,
        invoice_id: str,
        supplier_name: str,
        country: str,
        amount_eur: float,
        **entity_kwargs,
    ) -> tuple[bool, TrustResult]:
        """
        Top-level decision: should this invoice be paid autonomously?
        Returns (approved, trust_result).
        """
        result = self.verify(supplier_name, country, **entity_kwargs)

        approved = result.decision in (TrustDecision.PROCEED, TrustDecision.REVIEW)

        print(
            f"Invoice {invoice_id} | Supplier: {supplier_name} | "
            f"Amount: €{amount_eur:.2f} | "
            f"Trust: {result.score}/100 ({result.decision.value}) | "
            f"Cost: ${result.paid_usdc:.3f} USDC"
        )

        return approved, result


# ------------------------------------------------------------------ #
# Usage                                                                #
# ------------------------------------------------------------------ #

agent = TrustGatedAgent(wallet_private_key=os.environ["AGENT_WALLET_KEY"])

approved, trust = agent.should_pay_invoice(
    invoice_id="INV-2024-447",
    supplier_name="Acme Corp BV",
    country="NL",
    amount_eur=500.00,
    kvk_number="12345678",
    domain="acme-corp.nl",
)

if approved:
    print(f"Proceeding with payment. Cluster: {trust.cluster}")
    # execute_payment(...)
else:
    print(f"Payment blocked. Score: {trust.score}. Alerting operator.")
    # alert_operator(...)

import { ethers } from "ethers";

const USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
const CHAIN_ID = "eip155:8453";
const BASE_URL = "https://api.limitguard.ai";

const TrustDecision = {
  PROCEED: "proceed",
  REVIEW: "review",
  ENHANCED_DUE_DILIGENCE: "enhanced_due_diligence",
  BLOCK: "block",
};

const TIER_PRICES = { cached: 10_000, fresh: 50_000, enhanced: 150_000 };

class TrustGatedAgent {
  constructor(privateKey) {
    const provider = new ethers.JsonRpcProvider("https://mainnet.base.org");
    this.signer = new ethers.Wallet(privateKey, provider);
    this._discoveryCache = null;
  }

  async discover() {
    if (!this._discoveryCache) {
      const res = await fetch(`${BASE_URL}/.well-known/x402.json`);
      this._discoveryCache = await res.json();
    }
    return this._discoveryCache;
  }

  async getPrice(endpoint, quality = "fresh") {
    const listing = await this.discover();
    const entry = listing.endpoints.find((e) => e.path === endpoint);
    if (!entry) throw new Error(`Endpoint ${endpoint} not in discovery listing`);
    const price = entry.quality_tiers?.[quality] ?? entry.price_usdc ?? "0.05";
    return Math.round(parseFloat(price) * 1_000_000);
  }

  async getFacilitator(endpoint, payload) {
    const probe = await fetch(`${BASE_URL}${endpoint}`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(payload),
    });
    if (probe.status !== 402) throw new Error(`Expected 402, got ${probe.status}`);
    const { accepts } = await probe.json();
    const base = accepts.find((a) => a.chainId === CHAIN_ID);
    return (base ?? accepts[0]).recipient;
  }

  async buildPayment(amount, recipient) {
    const chainNum = parseInt(CHAIN_ID.split(":")[1]);
    const nonce =
      "0x" +
      [...crypto.getRandomValues(new Uint8Array(32))]
        .map((b) => b.toString(16).padStart(2, "0"))
        .join("");
    const now = Math.floor(Date.now() / 1000);

    const domain = {
      name: "USD Coin",
      version: "2",
      chainId: chainNum,
      verifyingContract: USDC_BASE,
    };
    const types = {
      TransferWithAuthorization: [
        { name: "from", type: "address" },
        { name: "to", type: "address" },
        { name: "value", type: "uint256" },
        { name: "validAfter", type: "uint256" },
        { name: "validBefore", type: "uint256" },
        { name: "nonce", type: "bytes32" },
      ],
    };
    const message = {
      from: this.signer.address,
      to: recipient,
      value: amount,
      validAfter: now - 10,
      validBefore: now + 300,
      nonce,
    };

    const signature = await this.signer.signTypedData(domain, types, message);

    return btoa(
      JSON.stringify({
        chainId: CHAIN_ID,
        amount: String(amount),
        sender: this.signer.address,
        recipient,
        nonce,
        signature,
        validAfter: now - 10,
        validBefore: now + 300,
      })
    );
  }

  async call(endpoint, payload, quality) {
    const amount = await this.getPrice(endpoint, quality);
    const facilitator = await this.getFacilitator(endpoint, payload);
    const xPayment = await this.buildPayment(amount, facilitator);

    const res = await fetch(`${BASE_URL}${endpoint}`, {
      method: "POST",
      headers: {
        "X-PAYMENT": xPayment,
        "X-Response-Quality": quality,
        "Content-Type": "application/json",
      },
      body: JSON.stringify(payload),
    });
    if (!res.ok) throw new Error(`LimitGuard error: ${res.status}`);
    return res.json();
  }

  scoreToDecision(score) {
    if (score >= 80) return TrustDecision.PROCEED;
    if (score >= 60) return TrustDecision.REVIEW;
    if (score >= 40) return TrustDecision.ENHANCED_DUE_DILIGENCE;
    return TrustDecision.BLOCK;
  }

  async verify(entityName, country, extras = {}) {
    const payload = { entity_name: entityName, country, ...extras };
    let totalPaid = 0;

    // Pass 1: Fast pre-screen
    const riskData = await this.call("/v1/risk/score", payload, "cached");
    totalPaid += 0.01;
    const preScore = riskData.risk_score ?? 50;

    if (preScore > 80) {
      return {
        score: 100 - preScore,
        level: "high_risk",
        decision: TrustDecision.BLOCK,
        cluster: "unknown",
        paidUsdc: totalPaid,
      };
    }

    // Pass 2: Full entity check
    const trustData = await this.call("/v1/entity/check", payload, "fresh");
    totalPaid += 0.05;

    return {
      score: trustData.trust_score,
      level: trustData.trust_level,
      decision: this.scoreToDecision(trustData.trust_score),
      cluster: trustData.cluster ?? "unknown",
      sourcesChecked: trustData.sources_checked ?? [],
      processingMs: trustData.processing_time_ms ?? 0,
      paidUsdc: totalPaid,
    };
  }

  async shouldPayInvoice(invoiceId, supplierName, country, amountEur, extras = {}) {
    const result = await this.verify(supplierName, country, extras);
    const approved = [TrustDecision.PROCEED, TrustDecision.REVIEW].includes(
      result.decision
    );

    console.log(
      `Invoice ${invoiceId} | ${supplierName} | €${amountEur} | ` +
        `Trust: ${result.score}/100 (${result.decision}) | ` +
        `Cost: $${result.paidUsdc.toFixed(3)} USDC`
    );

    return { approved, result };
  }
}

// Usage
const agent = new TrustGatedAgent(process.env.AGENT_WALLET_KEY);

const { approved, result } = await agent.shouldPayInvoice(
  "INV-2024-447",
  "Acme Corp BV",
  "NL",
  500.0,
  { kvk_number: "12345678", domain: "acme-corp.nl" }
);

if (approved) {
  console.log(`Proceeding. Cluster: ${result.cluster}`);
} else {
  console.log(`Blocked. Score: ${result.score}. Alerting operator.`);
}

import httpx

def load_limitguard_context(full: bool = False) -> str:
    """Load LimitGuard API context for injection into an LLM prompt."""
    url = "https://api.limitguard.ai/llms-full.txt" if full else "https://api.limitguard.ai/llms.txt"
    response = httpx.get(url, timeout=5.0)
    response.raise_for_status()
    return response.text


# Inject into a system prompt for a coding assistant
context = load_limitguard_context(full=True)

system_prompt = f"""You are a payment automation assistant.
You have access to the LimitGuard Trust Intelligence API.

{context}

Before authorizing any payment, call the entity check endpoint.
Block all transactions where recommendation is 'block'.
"""

async function loadLimitGuardContext(full = false) {
  const url = full
    ? "https://api.limitguard.ai/llms-full.txt"
    : "https://api.limitguard.ai/llms.txt";
  const res = await fetch(url);
  return res.text();
}

// Inject into a system prompt
const context = await loadLimitGuardContext(true);

const systemPrompt = `You are a payment automation assistant.
You have access to the LimitGuard Trust Intelligence API.

${context}

Before authorizing any payment, call the entity check endpoint.
Block all transactions where recommendation is 'block'.`;

import httpx

def verify_entity_sandbox(entity_name: str, country: str, api_key: str) -> dict:
    """Sandbox mode — deterministic mock data, no payment, no quota."""
    response = httpx.post(
        "https://api.limitguard.ai/v1/entity/check",
        headers={
            "X-API-Key": api_key,
            "X-LimitGuard-Mode": "sandbox",
            "Content-Type": "application/json",
        },
        json={"entity_name": entity_name, "country": country},
        timeout=5.0,
    )
    response.raise_for_status()
    return response.json()

# Sandbox response is deterministic — useful for unit tests
result = verify_entity_sandbox("Any Company", "NL", api_key="lg_live_xxxxxxxxxxxxxxxxxxxx")
# Always returns: trust_score: 75, recommendation: "review"

import httpx

# lg_test_ keys automatically activate sandbox for all requests
# No header needed — useful for CI/CD where you don't want accidental live calls
def verify_entity(entity_name: str, country: str) -> dict:
    response = httpx.post(
        "https://api.limitguard.ai/v1/entity/check",
        headers={"X-API-Key": "lg_test_xxxxxxxxxxxxxxxxxxxx"},
        json={"entity_name": entity_name, "country": country},
    )
    response.raise_for_status()
    return response.json()

// Sandbox via environment variable toggle
const isSandbox = process.env.NODE_ENV !== "production";

async function verifyEntity(entityName, country) {
  const headers = {
    "X-API-Key": process.env.LIMITGUARD_API_KEY,
    "Content-Type": "application/json",
  };

  if (isSandbox) {
    headers["X-LimitGuard-Mode"] = "sandbox";
  }

  const res = await fetch("https://api.limitguard.ai/v1/entity/check", {
    method: "POST",
    headers,
    body: JSON.stringify({ entity_name: entityName, country }),
  });

  return res.json();
}