AI Agent Integration Specification

curl -H "Accept: application/json" \
  https://anoteroslogos.com/.well-known/agent.json

curl -X POST https://anoteroslogos.com/api/public-aip \
  -H "Content-Type: application/json" \
  -d '{
    "name": "MyAgent",
    "description": "Optional description",
    "capabilities": ["geo.audit"]
  }'

curl https://anoteroslogos.com/api/capabilities

import { UAPClient } from '@anoteroslogos/uap-client';

const client = new UAPClient({
  agentId: 'agent://myagent.example.com',
  privateKey: process.env.AGENT_PRIVATE_KEY!,
  serverUrl: 'https://anoteroslogos.com:8443'
});

// Automatic handshake on connect
await client.connect({
  capabilities: ['geo.audit', 'knowledge.graph'],
  metadata: {
    version: '1.0.0',
    environment: 'production'
  }
});

console.log('Session ID:', client.sessionId);
console.log('Trust Score:', client.trustScore); // 0-100

import { UAPClient } from '@anoteroslogos/uap-client';

const client = new UAPClient({
  agentId: 'agent://myagent.example.com',
  privateKey: process.env.AGENT_PRIVATE_KEY!,
  serverUrl: 'wss://anoteroslogos.com:8080', // WebSocket
  options: {
    autoReconnect: true,
    maxReconnectAttempts: 5,
    reconnectBackoff: 'exponential', // 1s, 2s, 4s, 8s, 16s
    heartbeatInterval: 30000
  }
});

client.on('connected', (session) => {
  console.log('Connected, session:', session.id);
});

client.on('disconnected', (reason) => {
  console.log('Disconnected:', reason);
});

client.on('reconnecting', (attempt) => {
  console.log('Reconnecting attempt', attempt);
});

// Send message with correlation tracking
const response = await client.sendMessage({
  type: 'Request',
  method: 'geo.audit',
  params: { url: 'https://example.com' },
  correlationId: client.generateCorrelationId()
});

console.log('GEO Score:', response.result.score);

import { UAPClient } from '@anoteroslogos/uap-client';

// 1. Initialize UAP client
const uap = new UAPClient({
  agentId: 'agent://myagent.example.com',
  privateKey: process.env.AGENT_PRIVATE_KEY!,
  serverUrl: 'wss://anoteroslogos.com:8080'
});

// 2. Connect with capabilities (automatic handshake)
await uap.connect({
  capabilities: ['geo.audit', 'a2a.rpc'],
  metadata: { version: '1.0.0' }
});

console.log('UAP Session ID:', uap.sessionId);
console.log('Trust Score:', uap.trustScore); // Must be ≥50

// 3. Send A2A JSON-RPC via UAP Request message
const correlationId = uap.generateCorrelationId();
const response = await uap.sendMessage({
  type: 'Request',
  correlationId,
  payload: {
    jsonrpc: '2.0',
    method: 'geo.audit.request',
    params: {
      url: 'https://example.com',
      depth: 'standard'
    },
    id: 1
  }
});

// 4. Extract A2A result from UAP Response
const a2aResult = response.payload.result;
console.log('GEO Score:', a2aResult.score);
console.log('Issues:', a2aResult.issues.length);

// 5. Trust attestation included in response
console.log('Response Trust Score:', response.metadata.trustScore);
console.log('Watermark Valid:', response.metadata.watermarkValid);

// 6. Graceful session termination
await uap.disconnect();

curl -X POST https://anoteroslogos.com/api/a2a \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "a2a.discover",
    "params": {},
    "id": 1
  }'

curl -X POST https://anoteroslogos.com/api/a2a \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk_pro_abc123..." \
  -d '{
    "jsonrpc": "2.0",
    "method": "geo.audit.request",
    "params": {
      "url": "https://example.com",
      "depth": "standard",
      "include_recommendations": true
    },
    "id": 2
  }'

const response = await fetch('https://anoteroslogos.com/api/a2a', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${apiKey}`
  },
  body: JSON.stringify({
    jsonrpc: '2.0',
    method: 'geo.audit.batch',
    params: {
      urls: [
        'https://site1.com',
        'https://site2.com',
        'https://site3.com'
      ]
    },
    id: 3
  })
});

const eventSource = new EventSource(
  `https://anoteroslogos.com/api/a2a/tasks/${taskId}/stream`,
  { headers: { 'Authorization': `Bearer ${apiKey}` } }
);

eventSource.addEventListener('task.progress', (event) => {
  const data = JSON.parse(event.data);
  console.log(`Progress: ${data.progress * 100}%`);
});

eventSource.addEventListener('task.completed', (event) => {
  const data = JSON.parse(event.data);
  console.log('Result:', data.result);
  eventSource.close();
});

eventSource.addEventListener('task.failed', (event) => {
  const data = JSON.parse(event.data);
  console.error('Error:', data.error);
  eventSource.close();
});

eventSource.onerror = (error) => {
  console.error('Stream error:', error);
  eventSource.close();
};

import { orchestrate } from '@anoteroslogos/a2a-sdk';

const result = await orchestrate({
  execution: 'sequential',
  steps: [
    {
      agent: 'geo-audit',
      method: 'geo.audit.request',
      params: { url: 'https://example.com', depth: 'deep' }
    },
    {
      agent: 'knowledge-graph',
      method: 'knowledge.graph.extract',
      params: { url: 'https://example.com' }
    },
    {
      agent: 'citation-predictor',
      method: 'citation.predict',
      params: {
        domain: 'example.com',
        graph: '{{steps[1].result}}' // Reference previous step
      }
    }
  ]
});

console.log('GEO Score:', result.steps[0].result.score);
console.log('Entities:', result.steps[1].result.entities.length);
console.log('Citation Probability:', result.steps[2].result.probability);

curl -X POST https://anoteroslogos.com/api/a2a \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk_basic_..." \
  -d '{
    "jsonrpc": "2.0",
    "method": "a2a.mesh.discover",
    "params": {
      "capability": "geo.audit",
      "max_peers": 10
    },
    "id": 1
  }'

const response = await fetch('https://anoteroslogos.com/api/a2a', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${apiKey}`
  },
  body: JSON.stringify({
    jsonrpc: '2.0',
    method: 'a2a.mesh.announce',
    params: {
      capabilities: ['geo.audit', 'citation.predict'],
      cost_per_call: {
        token: 'USDC',
        amount: 0.10
      }
    },
    id: 1
  })
});
const { result } = await response.json();
console.log('Announced as:', result.node_id);

// Broadcast knowledge graph delta to all peers
const response = await fetch('https://anoteroslogos.com/api/a2a', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${apiKey}`
  },
  body: JSON.stringify({
    jsonrpc: '2.0',
    method: 'a2a.mesh.sync',
    params: {
      type: 'knowledge_graph',
      payload: {
        entities: [{id: 'ent_123', type: 'Organization', name: 'ACME Corp'}],
        relationships: [{from: 'ent_123', to: 'ent_456', type: 'owns'}]
      }
    },
    id: 1
  })
});
const { result } = await response.json();
console.log('Broadcast to', result.broadcast, 'peers');

curl -X POST https://anoteroslogos.com/api/a2a \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk_pro_..." \
  -d '{
    "jsonrpc": "2.0",
    "method": "a2a.mesh.health",
    "params": {},
    "id": 1
  }'

import { ethers } from 'ethers';

const USDC_ADDRESS = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';
const BASE_RPC = 'https://mainnet.base.org';

async function auditWithPayment(url: string) {
  const apiKey = process.env.ANOTEROS_API_KEY;
  const wallet = new ethers.Wallet(process.env.AGENT_PRIVATE_KEY!);
  const provider = new ethers.JsonRpcProvider(BASE_RPC);
  const signer = wallet.connect(provider);

  // Step 1: Initial request (will return HTTP 402)
  let response = await fetch('https://anoteroslogos.com/api/a2a', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${apiKey}`
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      method: 'geo.audit.request',
      params: { url, depth: 'standard' },
      id: 1
    })
  });

  if (response.status === 402) {
    const error = await response.json();
    const invoice = error.error.data;

    // Step 2: Send USDC payment
    const usdcContract = new ethers.Contract(
      USDC_ADDRESS,
      ['function transfer(address to, uint256 amount) returns (bool)'],
      signer
    );

    const amountInUnits = ethers.parseUnits(invoice.amount.toString(), 6); // USDC has 6 decimals
    const tx = await usdcContract.transfer(
      invoice.recipientAddress,
      amountInUnits
    );

    console.log('Payment sent:', tx.hash);

    // Step 3: Wait for 2 confirmations
    await tx.wait(2);

    // Step 4: Retry request with payment proof
    response = await fetch('https://anoteroslogos.com/api/a2a', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${apiKey}`
      },
      body: JSON.stringify({
        jsonrpc: '2.0',
        method: 'geo.audit.request',
        params: {
          url,
          depth: 'standard',
          invoice_id: invoice.invoiceId,
          tx_hash: tx.hash
        },
        id: 1
      })
    });
  }

  // Step 5: Get audit result
  const result = await response.json();
  return result.result;
}

// Usage
const audit = await auditWithPayment('https://example.com');
console.log('GEO Score:', audit.score);

curl "https://anoteroslogos.com/api/tools/search?query=audit&limit=3"

import { sign } from 'tweetnacl';
import { encodeBase64 } from 'tweetnacl-util';

const privateKey = Uint8Array.from(/* your Ed25519 private key */);
const message = `(request-target): post /api/a2a
date: ${new Date().toUTCString()}
digest: SHA-256=${digest}`;

const signature = sign.detached(
  new TextEncoder().encode(message),
  privateKey
);

const authHeader = `Signature keyId="anoteroslogos-2025-primary",algorithm="ed25519",headers="(request-target) date digest",signature="${encodeBase64(signature)}"`;

import { DynamicStructuredTool } from "@langchain/core/tools";
import { z } from "zod";

const geoAuditTool = new DynamicStructuredTool({
  name: "audit_site_geo",
  description: "Audit website for AI visibility (GEO score)",
  schema: z.object({
    url: z.string().url(),
    depth: z.enum(["quick", "standard", "deep"]).default("standard")
  }),
  func: async ({ url, depth }) => {
    const response = await fetch('https://anoteroslogos.com/api/a2a', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${process.env.ANOTEROS_API_KEY}`
      },
      body: JSON.stringify({
        jsonrpc: '2.0',
        method: 'geo.audit.request',
        params: { url, depth },
        id: Date.now()
      })
    });
    const result = await response.json();
    return JSON.stringify(result.result);
  }
});

{
  "mcpServers": {
    "anteroslogos": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-fetch"],
      "env": {
        "ANOTEROS_API_KEY": "sk_pro_...",
        "MCP_SERVER_URL": "https://anoteroslogos.com/api/mcp"
      }
    }
  }
}