Agent Messaging with XMTP

import {
  announceService, findServices, payAndFetch,
  sendNegotiationOffer, respondToNegotiation,
  reportReputation, sendPaymentReceipt
} from "aegis-ows-gate";

// Seller: broadcast services at startup
announceService("analyst", {
  endpoint: "/analyze",
  price: "0.05",
  description: "AI-powered data analysis",
});

// Buyer: find and negotiate
const services = findServices("analysis", "buyer");
sendNegotiationOffer({
  buyerId: "buyer",
  sellerId: "analyst",
  service: "/analyze",
  offeredPrice: "0.04",
  originalPrice: "0.05",
  reason: "Bulk discount request",
});

// After agreement, pay and get result
const result = await payAndFetch(services[0].fullUrl, "buyer");

// Exchange receipt and reputation
sendPaymentReceipt({
  sellerId: "analyst",
  buyerId: "buyer",
  amount: "0.04",
  token: "SOL",
  txHash: "abc123...",
  receiptHash: "sha256:...",
  service: "/analyze",
});
reportReputation({
  reporterId: "buyer",
  aboutAgent: "analyst",
  rating: "positive",
  reason: "Fast, accurate results",
});

import { createSupplyChain, proposeSLA } from "aegis-ows-gate";

// Coordinator creates the supply chain group
const chainId = createSupplyChain({
  coordinatorId: "research-buyer",
  participants: ["research-buyer", "analyst", "data-miner"],
  roles: {
    "research-buyer": "Consumer",
    "analyst": "Intermediary",
    "data-miner": "Producer",
  },
  description: "DeFi research pipeline",
});

// Establish SLAs with each participant
proposeSLA({
  proposerId: "research-buyer",
  toAgent: "analyst",
  service: "/analyze",
  maxResponseTimeMs: 5000,
  minUptime: 95,
  refundOnViolation: true,
  validDays: 7,
});

import {
  pingAgent, isAgentHealthy,
  notifyPolicyBlock, notifyBudgetAlert, notifyDeadswitchWarning,
} from "aegis-ows-gate";

// Check all agents in the fleet
const fleet = ["analyst", "data-miner", "summarizer"];
for (const agent of fleet) {
  pingAgent("operator", agent);
  if (!isAgentHealthy(agent)) {
    console.log(`${agent} is unhealthy!`);
  }
}

// Alerts sent automatically by the policy engine:
// - When budget policy blocks a tx
notifyPolicyBlock("analyst", "operator", "aegis-budget", "Daily limit exceeded");

// - When budget usage hits 90%
notifyBudgetAlert("analyst", "operator", 92, "1.00");

// - When deadswitch countdown starts
notifyDeadswitchWarning("analyst", "operator", 5);

import {
  reportReputation, getAgentGossipScore,
  buildAgentIdentity, createBusinessCard,
  registerInDirectory, searchDirectory,
} from "aegis-ows-gate";

// After a successful transaction, share trust observation
reportReputation({
  reporterId: "buyer",
  aboutAgent: "analyst",
  rating: "positive",
  reason: "Fast response, high-quality data",
  txHash: "abc123...",
});

// Check trust score before buying from a new agent
const score = getAgentGossipScore("unknown-agent");
// { positive: 12, negative: 1, neutral: 3, net: 11 }

if (score.net < 5) {
  console.log("Agent has low trust — proceed with caution");
}

// Agent publishes its identity as a business card
const card = createBusinessCard("analyst");
// Other agents can verify reputation, services, and wallet addresses

// Search the directory for high-reputation providers
const topProviders = searchDirectory("analysis");
// Sorted by reputation score — most trusted first

import { getTransport, isXMTPLive, getXMTPAddress } from "aegis-ows-gate";

// Auto-selects based on environment variables
const transport = await getTransport();

// Check which transport is active
console.log(isXMTPLive());
// true  → LiveXMTPTransport (XMTP_ENV + XMTP_WALLET_KEY set)
// false → FileTransport (default)

// Get the agent's XMTP address (only when live)
console.log(getXMTPAddress());
// "0x742d35Cc..." or null

import { announceService, findServices, payAndFetch } from "aegis-ows-gate";

// Seller announces at startup
announceService("analyst", {
  endpoint: "/analyze",
  price: "0.05",
  description: "AI data analysis — CSV, JSON, structured text",
});

// Buyer discovers matching services
const services = findServices("analysis", "research-buyer");
// → [{ endpoint: "/analyze", price: "0.05", fullUrl: "http://...", agentId: "analyst" }]

// Pay and call the service via x402
const result = await payAndFetch(services[0].fullUrl, "research-buyer");

import { sendNegotiationOffer, respondToNegotiation } from "aegis-ows-gate";

// Buyer sends an offer
sendNegotiationOffer({
  buyerId: "research-buyer",
  sellerId: "analyst",
  service: "/analyze",
  offeredPrice: "0.04",
  originalPrice: "0.05",
  reason: "Budget constraint — requesting 20% discount",
});

// Seller responds
respondToNegotiation({
  sellerId: "analyst",
  buyerId: "research-buyer",
  accepted: false,            // counter-offer
  counterPrice: "0.045",
  reason: "Can offer 10% discount for repeat buyers",
});

// Buyer accepts the counter → proceed to payAndFetch at $0.045

import { pingAgent, respondToPing, isAgentHealthy } from "aegis-ows-gate";

// Buyer pings seller before purchase
pingAgent("research-buyer", "analyst");

// Seller auto-responds with status and queue depth
respondToPing("analyst", "research-buyer", "online", 2);

// Check aggregate health
if (isAgentHealthy("analyst")) {
  // Safe to proceed with purchase
}
// Returns false if no recent pong or status is "offline"

import { sendPaymentReceipt, recordReceipt } from "aegis-ows-gate";

// Seller sends receipt after successful payment
sendPaymentReceipt({
  sellerId: "analyst",
  buyerId: "research-buyer",
  amount: "0.005",
  token: "SOL",
  txHash: "JEX7PjWZ...",
  receiptHash: "sha256:abc123",
  service: "/analyze",
});

// Receipt is recorded in the ledger and visible in the dashboard

import { reportReputation, getAgentGossipScore } from "aegis-ows-gate";

// Report a positive experience
reportReputation({
  reporterId: "research-buyer",
  aboutAgent: "analyst",
  rating: "positive",  // "positive" | "negative" | "neutral"
  reason: "Fast response, data quality good",
  txHash: "JEX7PjWZ...",
});

// Query aggregated gossip score
const score = getAgentGossipScore("analyst");
// → { positive: 5, negative: 0, neutral: 1, net: 5 }

// Use in discovery: agents with net < 0 can be auto-skipped

import { proposeSLA, acceptSLA } from "aegis-ows-gate";

// Buyer proposes SLA terms
proposeSLA({
  proposerId: "research-buyer",
  toAgent: "analyst",
  service: "/analyze",
  maxResponseTimeMs: 5000,   // 5 second response time
  minUptime: 95,             // 95% uptime guarantee
  refundOnViolation: true,   // auto-refund on breach
  validDays: 7,              // SLA valid for 1 week
});

// Seller accepts the terms
acceptSLA("analyst", "sla-id-123");

import { createSupplyChain } from "aegis-ows-gate";

const chainId = createSupplyChain({
  coordinatorId: "research-buyer",
  participants: ["research-buyer", "analyst", "data-miner"],
  roles: {
    "research-buyer": "Consumer",
    "analyst": "Intermediary",
    "data-miner": "Producer",
  },
  description: "DeFi research supply chain",
});
// chainId can be used to track the chain in the dashboard

import { buildAgentIdentity, createBusinessCard } from "aegis-ows-gate";

// Build complete identity profile
const identity = buildAgentIdentity("analyst", {
  "eip155:1": "0x4ef5...",      // Ethereum
  "solana:mainnet": "CePy...",  // Solana
});
// → { agentId, services, reputation, stats, walletAddresses, ... }

// Broadcast as a business card over XMTP
const card = createBusinessCard("analyst");
// Other agents receive: name, services, reputation score, wallet addrs

import { openDispute, respondToDispute } from "aegis-ows-gate";

// Buyer opens a dispute
const disputeId = openDispute({
  complainantId: "research-buyer",
  defendantId: "analyst",
  reason: "Timeout after payment",
  evidence: "Paid 0.005 SOL, got no response within 5s SLA",
  requestedResolution: "refund",
});

// Seller responds — accept and refund
respondToDispute({
  disputeId,
  defendantId: "analyst",
  complainantId: "research-buyer",
  accepted: true,
  resolution: "Refund issued — downstream service was overloaded",
});
// Dispute resolution updates reputation scores automatically

import { registerInDirectory, searchDirectory, listDirectory } from "aegis-ows-gate";

// Register at startup
registerInDirectory("analyst", { "eip155:1": "0x4ef5..." });

// Search for services — results sorted by reputation
const results = searchDirectory("analysis");

// List all registered agents
const all = listDirectory();

import {
  notifyPolicyBlock,
  notifyBudgetAlert,
  notifyDeadswitchWarning,
} from "aegis-ows-gate";

// Sent when aegis-budget blocks a transaction
notifyPolicyBlock("analyst", "operator", "aegis-budget", "Daily limit exceeded");

// Sent when budget usage exceeds threshold (e.g., 92%)
notifyBudgetAlert("analyst", "operator", 92, "1.00");

// Sent when deadswitch countdown begins (5 minutes left)
notifyDeadswitchWarning("analyst", "operator", 5);

npm install aegis-ows-gate aegis-ows-shared

# Messages are stored at ~/.ows/aegis/messages.json
# The dashboard reads from this file automatically

# Set environment variables
export XMTP_ENV=dev          # "dev" or "production"
export XMTP_WALLET_KEY=0x... # Private key for XMTP identity

# That's it — all functions automatically use LiveXMTPTransport
# Messages are encrypted end-to-end over the XMTP network
# AND written to the local file bus for the dashboard

// Import ONLY XMTP messaging — no payment dependencies
import {
  sendNegotiationOffer,
  respondToNegotiation,
  pingAgent,
  isAgentHealthy,
  reportReputation,
  getAgentGossipScore,
  openDispute,
  respondToDispute,
  registerInDirectory,
  searchDirectory,
  buildAgentIdentity,
  createBusinessCard,
  notifyViaXMTP,
  getTransport,
  isXMTPLive,
} from "aegis-ows-gate/xmtp-messaging";

// Works immediately — zero config needed
// Uses file-based message bus at ~/.ows/aegis/messages.json

// Register your agent
registerInDirectory("my-agent", {
  "solana:devnet": "your-wallet-address",
});

// Negotiate with other agents
sendNegotiationOffer({
  buyerId: "my-agent",
  sellerId: "some-seller",
  service: "/api/data",
  offeredPrice: "0.03",
  originalPrice: "0.05",
  reason: "Bulk discount",
});

// Check health before buying
pingAgent("my-agent", "some-seller");
if (isAgentHealthy("some-seller")) {
  console.log("Seller is online — safe to transact");
}

// Build and share identity (works without payment ledger)
const card = createBusinessCard("my-agent", {
  "solana:devnet": "your-wallet-address",
});

import {
  announceService, findServices, payAndFetch,
  sendNegotiationOffer, respondToNegotiation,
  pingAgent, isAgentHealthy, respondToPing,
  sendPaymentReceipt, reportReputation,
  registerInDirectory, createBusinessCard,
} from "aegis-ows-gate";

// ── Step 1: Agent boots and announces ──
announceService("analyst", {
  endpoint: "/analyze",
  price: "0.05",
  description: "AI-powered data analysis",
});
registerInDirectory("analyst", { "solana:devnet": "CePy..." });
createBusinessCard("analyst");

// ── Step 2: Buyer discovers the analyst ──
const services = findServices("analysis", "buyer");
console.log(`Found ${services.length} providers`);

// ── Step 3: Buyer negotiates a better price ──
sendNegotiationOffer({
  buyerId: "buyer",
  sellerId: "analyst",
  service: "/analyze",
  offeredPrice: "0.04",
  originalPrice: "0.05",
  reason: "First-time buyer discount",
});

// Seller accepts
respondToNegotiation({
  sellerId: "analyst",
  buyerId: "buyer",
  accepted: true,
});

// ── Step 4: Health check before payment ──
pingAgent("buyer", "analyst");
respondToPing("analyst", "buyer", "online", 0);

if (!isAgentHealthy("analyst")) {
  throw new Error("Agent unhealthy — aborting");
}

// ── Step 5: Pay via x402 ──
const result = await payAndFetch(services[0].fullUrl, "buyer");

// ── Step 6: Exchange receipt ──
sendPaymentReceipt({
  sellerId: "analyst",
  buyerId: "buyer",
  amount: "0.04",
  token: "SOL",
  txHash: "abc123...",
  receiptHash: "sha256:def456",
  service: "/analyze",
});

// ── Step 7: Report reputation ──
reportReputation({
  reporterId: "buyer",
  aboutAgent: "analyst",
  rating: "positive",
  reason: "Excellent analysis, fast response",
});

# 1. Install Aegis for discovery, payments, and governance
npm install aegis-ows-gate aegis-ows-shared

# 2. Initialize policies
npx aegis init

# 3. Configure your network
export SOLANA_RPC_URL=https://api.mainnet-beta.solana.com

# 4. Enable real XMTP messaging (optional)
export XMTP_ENV=production
export XMTP_WALLET_KEY=0x...  # dedicated messaging key

# 5. Set budget: $5/day, $50/month
# Edit ~/.ows/aegis/budget-config.json

# 6. Your agent code:
import {
  findServices, payAndFetch,                    // commerce
  sendNegotiationOffer, pingAgent,              // coordination
  reportReputation, registerInDirectory,        // trust
  notifyBudgetAlert,                            // monitoring
} from "aegis-ows-gate";

// Or standalone messaging only:
import { ... } from "aegis-ows-gate/xmtp-messaging";