AI Agent Integration

import anthropic

client = anthropic.Anthropic()

# Register Limitguard as an MCP server
# Claude will call check_entity 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 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",
      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") {
    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")

        # Every skill in the agent card names its own REST endpoint and method
        response = httpx.request(
            skill["method"],
            f"{self.BASE_URL}{skill['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: ['lead_verify', 'agent_check', 'entity_check', 'risk_score', 'kyb_check']

# Invoke entity trust check
result = client.invoke(
    "entity_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`);

    // Every skill in the agent card names its own REST endpoint and method
    const res = await fetch(`${this.baseUrl}${skill.endpoint}`, {
      method: skill.method,
      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_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 (1_000_000 = $1.00), from the 402
    sender_key: str,     # agent wallet private key
    recipient: str,      # payTo address from the 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
) -> dict:
    # Step 1: Probe for the quote. The 402 carries the exact amount for this
    # endpoint and quality tier, so no price is hard-coded here.
    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}"
    accepted = next(
        a
        for a in probe.json()["accepts"]
        if a["network"] == CHAIN_ID and a["scheme"] == "exact"
    )
    amount = int(accepted["amount"])

    # Step 2: Build payment and call
    x_payment = build_x402_payment(amount, sender_key, accepted["payTo"])

    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") {
  // Step 1: Probe for the quote. The 402 carries the exact amount for this
  // endpoint and quality tier, so no price is hard-coded here.
  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 accepted = accepts.find((a) => a.network === CHAIN_ID && a.scheme === "exact");
  const amount = parseInt(accepted.amount, 10);

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

  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"

    # Prices are read from each 402 quote, never hard-coded: the quote carries the
    # exact amount (USDC 6-decimal units) for the endpoint and quality tier asked for.

    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 is_listed(self, endpoint: str) -> bool:
        """True if the x402 listing sells this endpoint."""
        return any(e["path"] == endpoint for e in self.discover()["endpoints"])

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

    def _quote(self, endpoint: str, payload: dict, quality: str) -> dict:
        """Probe an endpoint without payment and return its Base "exact" quote."""
        if not self.is_listed(endpoint):
            raise ValueError(f"Endpoint {endpoint} not in discovery listing")
        probe = httpx.post(
            f"{self.BASE_URL}{endpoint}",
            headers={"X-Response-Quality": quality, "Content-Type": "application/json"},
            json=payload,
            timeout=10.0,
        )
        if probe.status_code != 402:
            raise RuntimeError(f"Expected 402 probe, got {probe.status_code}")
        for option in probe.json()["accepts"]:
            if option["network"] == self.CHAIN_ID and option["scheme"] == "exact":
                return option
        raise RuntimeError(f"No {self.CHAIN_ID} option in the 402 quote")

    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) -> tuple[dict, int]:
        """Make a paid API call. Returns the response and the amount paid."""
        quote = self._quote(endpoint, payload, quality)
        amount = int(quote["amount"])  # exactly what the 402 asked for
        x_payment = self._build_payment(amount, quote["payTo"])

        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(), amount

    # ------------------------------------------------------------------ #
    # 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 (cached tier)
        risk_data, paid = self._call("/v1/risk/score", payload, quality="cached")
        total_paid += paid / 1_000_000
        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 (fresh tier)
        trust_data, paid = self._call("/v1/entity/check", payload, quality="fresh")
        total_paid += paid / 1_000_000

        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",
};

// Prices are read from each 402 quote, never hard-coded: the quote carries the
// exact amount (USDC 6-decimal units) for the endpoint and quality tier asked for.

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 quote(endpoint, payload, quality) {
    const listing = await this.discover();
    if (!listing.endpoints.some((e) => e.path === endpoint)) {
      throw new Error(`Endpoint ${endpoint} not in discovery listing`);
    }
    const probe = await fetch(`${BASE_URL}${endpoint}`, {
      method: "POST",
      headers: { "X-Response-Quality": quality, "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.network === CHAIN_ID && a.scheme === "exact");
    if (!base) throw new Error(`No ${CHAIN_ID} option in the 402 quote`);
    return base;
  }

  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 quote = await this.quote(endpoint, payload, quality);
    const amount = parseInt(quote.amount, 10); // exactly what the 402 asked for
    const xPayment = await this.buildPayment(amount, quote.payTo);

    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 { data: await res.json(), amount };
  }

  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 (cached tier)
    const { data: riskData, amount: riskPaid } = await this.call("/v1/risk/score", payload, "cached");
    totalPaid += riskPaid / 1_000_000;
    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 (fresh tier)
    const { data: trustData, amount: trustPaid } = await this.call("/v1/entity/check", payload, "fresh");
    totalPaid += trustPaid / 1_000_000;

    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 lead and company check 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 lead and company check API.

${context}

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

import httpx

# Once: a free sandbox key (no wallet, no payment)
SANDBOX_KEY = httpx.post(
    "https://api.limitguard.ai/v1/keys/create",
    json={"email": "you@example.com", "tier": "sandbox"},
).json()["api_key"]  # lg_sandbox_...

def verify_entity(entity_name: str, country: str, api_key: str) -> dict:
    """The same call in sandbox and production; only the key differs."""
    response = httpx.post(
        "https://api.limitguard.ai/v1/entity/check",
        headers={"X-API-Key": api_key, "Content-Type": "application/json"},
        json={"entity_name": entity_name, "country": country},
        timeout=10.0,
    )
    response.raise_for_status()
    return response.json()

# Sandbox response is deterministic: useful for unit tests
result = verify_entity("Any Company", "NL", api_key=SANDBOX_KEY)
# Always returns: trust_score: 75, recommendation: "review", sandbox: true

// Pick the key by environment: the sandbox key can never trigger a paid call
const apiKey = process.env.NODE_ENV === "production"
  ? process.env.LIMITGUARD_API_KEY          // lg_live_...
  : process.env.LIMITGUARD_SANDBOX_KEY;     // lg_sandbox_...

async function verifyEntity(entityName, country) {
  const res = await fetch("https://api.limitguard.ai/v1/entity/check", {
    method: "POST",
    headers: { "X-API-Key": apiKey, "Content-Type": "application/json" },
    body: JSON.stringify({ entity_name: entityName, country }),
  });
  return res.json();
}