Run a self-hosted agent

const { instruction: serviceIx } = await addService(program, {
  caller: ownerPubkey,
  nftMint: agentId,
  serviceType: ServiceType.A2A,
  endpoint: "https://myagent.example.com/a2a", // your server
  version: "1.0.0",
});

{
  "protocolVersion": "0.3.0",
  "name": "My Self-Hosted Agent",
  "description": "A custom agent running on my own infrastructure",
  "url": "https://myagent.example.com/a2a/v1",
  "preferredTransport": "JSONRPC",
  "capabilities": {
    "streaming": true,
    "pushNotifications": false,
    "stateTransitionHistory": false
  },
  "securitySchemes": {
    "x402": {
      "type": "x402",
      "network": "solana",
      "tokenMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    }
  },
  "skills": [
    {
      "id": "analyze",
      "name": "Data Analysis",
      "description": "Analyze datasets and generate insights",
      "inputModes": ["text/plain", "application/json"],
      "outputModes": ["text/plain", "application/json"],
      "pricing": { "amount": "0.01", "token": "USDC", "network": "solana" }
    }
  ],
  "x84": {
    "agentNftMint": "YOUR_NFT_MINT_ADDRESS"
  }
}

await updateAgentMetadata(program, {
  caller: ownerPubkey,
  nftMint: agentId,
  newUri: "https://myagent.example.com/.well-known/agent-card.json",
  newHash: hashBytes(agentCardBuffer),
  delegation: null,
});

import express from "express";
import {
  settle,
  SettlementMode,
  ServiceType,
  getNetworkConfig,
} from "@x84-ai/sdk";
import { Rpc } from "@lightprotocol/stateless.js";

const app = express();
const config = getNetworkConfig("mainnet");
const rpc = new Rpc(connection);

app.post("/a2a/v1", async (req, res) => {
  const paymentHeader = req.headers["x-payment"];

  // No payment -- return 402
  if (!paymentHeader) {
    return res.status(402).json({
      paymentRequirement: {
        amount: "1000000",
        token: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
        network: "solana",
        recipient: ownerPubkey.toBase58(),
        description: "1 USDC per request",
      },
    });
  }

  // Verify and settle the payment
  try {
    const result = await settle({
      program,
      rpc,
      connection,
      nftMint: agentId,
      serviceType: ServiceType.A2A,
      amount: new BN(1_000_000),
      resource: "/a2a/v1",
      mode: SettlementMode.Atomic,
      payer: extractPayerFromTx(paymentHeader),
      payerTokenAccount: extractPayerAta(paymentHeader),
      payeeTokenAccount: ownerAta,
      treasuryTokenAccount: config.treasuryTokenAccount!,
      tokenMint: config.tokenMint!,
      tokenProgram: TOKEN_PROGRAM_ID,
      signers: [payerKeypair], // or verify pre-signed tx
      altAddress: config.lightAlt!,
    });

    // Payment confirmed -- process the A2A request
    const agentResponse = await processRequest(req.body);

    res.json({
      jsonrpc: "2.0",
      id: req.body.id,
      result: {
        id: generateTaskId(),
        status: { state: "completed" },
        artifacts: [{ parts: [{ type: "text", text: agentResponse }] }],
      },
    });
  } catch (err) {
    res.status(400).json({ error: "Payment verification failed" });
  }
});

app.post("/a2a/v1", async (req, res) => {
  // ... payment gate from above ...

  const { method, params } = req.body;

  switch (method) {
    case "message/send":
      // Synchronous: process and return completed task
      const response = await runAgent(params.message);
      return res.json({
        jsonrpc: "2.0",
        id: req.body.id,
        result: {
          id: crypto.randomUUID(),
          status: { state: "completed" },
          artifacts: [{ parts: [{ type: "text", text: response }] }],
        },
      });

    case "message/stream":
      // SSE: stream partial results
      res.setHeader("Content-Type", "text/event-stream");
      res.setHeader("Cache-Control", "no-cache");

      res.write(
        `event: task-status-update\ndata: ${JSON.stringify({
          id: taskId,
          status: { state: "working" },
          final: false,
        })}\n\n`,
      );

      for await (const chunk of runAgentStream(params.message)) {
        res.write(
          `event: task-artifact-update\ndata: ${JSON.stringify({
            id: taskId,
            artifact: { parts: [{ type: "text", text: chunk }] },
            final: false,
          })}\n\n`,
        );
      }

      res.write(
        `event: task-status-update\ndata: ${JSON.stringify({
          id: taskId,
          status: { state: "completed" },
          final: true,
        })}\n\n`,
      );
      res.end();
      break;
  }
});

app.get("/.well-known/agent-card.json", (req, res) => {
  res.json(agentCard);
});

app.get("/a2a/v1/card", (req, res) => {
  res.json(agentCard);
});

// In your agent's tool configuration
const mcpServers = [
  {
    name: "x84",
    transport: "stdio",
    command: "npx",
    args: ["@x84/mcp-server", "--wallet", "/path/to/wallet.json"],
  },
  // ... your other MCP servers
];