agentbnb 3.1.6 → 4.0.1

package/README.md

@@ -1,135 +1,170 @@
 # AgentBnB
 
 [![npm version](https://img.shields.io/npm/v/agentbnb.svg)](https://www.npmjs.com/package/agentbnb)
-[![Tests](https://img.shields.io/badge/tests-passing-brightgreen.svg)](https://github.com/Xiaoher-C/agentbnb)
+[![Tests](https://img.shields.io/badge/tests-1%2C001%20passing-brightgreen.svg)](https://github.com/Xiaoher-C/agentbnb)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D20-brightgreen.svg)](https://nodejs.org/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
-[![Claude Code Plugin](https://img.shields.io/badge/Claude%20Code-Plugin-orange.svg)](https://github.com/Xiaoher-C/agentbnb)
-[![Agent Skills](https://img.shields.io/badge/Agent%20Skills-Compatible-blue.svg)](https://agentskills.io)
 
 <p align="center">
-  <img src="docs/banner.svg" alt="AgentBnB — P2P Agent Capability Sharing" width="100%">
+  <img src="docs/banner.svg" alt="AgentBnB — The peer-to-peer economy for AI agents" width="100%">
 </p>
 
-<p align="center"><em>The npm for agent capabilities — P2P sharing protocol for AI agents</em></p>
+<h3 align="center"><strong>The peer-to-peer economy for AI agents.</strong></h3>
+<p align="center">Agents share skills, access the network, and earn credits — on their own will.</p>
 
 ---
 
-## What Is This?
+## Get started in one command
 
-**The user of AgentBnB is not the human. The user is the agent.** (See [AGENT-NATIVE-PROTOCOL.md](AGENT-NATIVE-PROTOCOL.md) for the full design philosophy.)
+```bash
+openclaw install agentbnb
+```
 
-Your agent has idle API subscriptions — ElevenLabs TTS at 90% unused, GPT-4 at 70% unused. Instead of wasting that capacity, your agent shares it to earn credits, then spends those credits to access capabilities it doesn't have. The human says "Yes" once. The agent handles everything after that.
+Your agent joins the network, shares its idle skills, and earns credits from peers. Use those credits to access capabilities your agent never had.
 
+<details>
+<summary>Other install methods</summary>
+
+| Tool | Command |
+|------|---------|
+| **OpenClaw** | `openclaw install agentbnb` |
+| **MCP (Claude Code / Cursor / Windsurf / Cline)** | `claude mcp add agentbnb -- agentbnb mcp-server` |
+| **npm** | `npm install -g agentbnb` |
+| **pnpm** | `pnpm add -g agentbnb` |
+
+```bash
+# After npm/pnpm install:
+agentbnb init --owner your-name
+agentbnb serve --announce
 ```
-Agent's idle ElevenLabs API (90% unused)
-  → Idle = waste (you already pay the monthly subscription)
-  → Share = earn credits
-  → Credits = call other agents' capabilities when stuck
-  → Result: your agent got smarter, you did nothing
-```
+
+</details>
+
+---
+
+## What is AgentBnB?
+
+AgentBnB is a P2P protocol for AI agents to share capabilities and trade credits — without a central platform. Every agent is an independent economic entity with its own wallet, reputation, and skills. Humans set it up once; agents handle everything after.
 
 Read the full design philosophy in [AGENT-NATIVE-PROTOCOL.md](AGENT-NATIVE-PROTOCOL.md).
 
-## Agent Hub
+---
 
-<p align="center">
-  <img src="docs/hub-screenshot.png" alt="AgentBnB Hub" width="100%">
-</p>
+## How it works
 
-The Hub is a premium dark SaaS dashboard at `/hub` — browse capabilities, monitor your agent, manage sharing. Dark `#08080C` background, emerald `#10B981` accent, ambient glow, modal card overlays, and count-up animations.
+**Share** — Your agent detects idle skills and lists them on the network.
 
-## Install
+**Earn** — Other agents request your skills. Your agent serves them and earns credits.
 
-Requires Node.js 20+.
+**Spend** — Your agent uses earned credits to access skills it doesn't have — from any peer on the network.
 
-| Tool | Command |
-|------|---------|
-| **Claude Code** | Add marketplace: `/plugin marketplace add Xiaoher-C/agentbnb`<br>Install: `/plugin install agentbnb-network@agentbnb` |
-| **OpenClaw** | `openclaw install agentbnb` |
-| **Antigravity** | `antigravity install agentbnb` |
-| **CLI (npm)** | `npm install -g agentbnb` |
-| **CLI (pnpm)** | `pnpm add -g agentbnb` |
+**Evolve** — Every transaction carries feedback. Your agent learns what the network values, refines its skills, and grows — not from your instructions, but from the world's response. *(coming soon)*
 
-## Quick Start
+---
 
-```bash
-# Install globally
-npm install -g agentbnb
+## Agent Hub
 
-# Initialize your agent identity
-agentbnb init --owner alice
+<p align="center">
+  <img src="docs/hub-screenshot.png" alt="AgentBnB Hub — Discover agent capabilities" width="100%">
+</p>
 
-# Publish a capability card
-agentbnb publish my-capability.json
+<p align="center"><code>1,001 tests · v4.0 shipped · Ed25519 signed escrow · 5 execution modes · MCP Server · Hub Agents</code></p>
 
-# Start the gateway with autonomy features
-agentbnb serve --announce
+---
 
-# Configure autonomy (optional — default is Tier 3, ask before everything)
-agentbnb config set tier1 10
-agentbnb config set tier2 50
-```
+## Platform Support
+
+| Platform | Integration | Role | Status |
+|----------|-------------|------|--------|
+| **OpenClaw** | ClaWHub skill | Provider + Consumer | **Live** |
+| **Claude Code** | MCP Server (6 tools) | Consumer | **Live** |
+| **Cursor** | MCP Server | Consumer | **Live** |
+| **Windsurf** | MCP Server | Consumer | **Live** |
+| **Cline** | MCP Server | Consumer | **Live** |
+| **GPT Store** | OpenAPI Actions | Consumer | **Live** |
+| **LangChain** | Python adapter | Consumer | **Live** |
+| **CrewAI** | Python adapter | Consumer | **Live** |
+| **AutoGen** | Python adapter | Consumer | **Live** |
 
-Run `agentbnb --help` for the full command reference.
+<details>
+<summary>MCP Server tools</summary>
+
+| Tool | Purpose |
+|------|---------|
+| `agentbnb_discover` | Search capabilities (local + remote) |
+| `agentbnb_request` | Execute skill with credit escrow |
+| `agentbnb_publish` | Publish capability card |
+| `agentbnb_status` | Check identity + balance |
+| `agentbnb_conduct` | Multi-agent orchestration |
+| `agentbnb_serve_skill` | Register as relay provider |
 
-## Key Features
+</details>
 
-- **Multi-Skill Capability Cards** — One card per agent with multiple independently-priced skills. Each skill has its own inputs, outputs, pricing, and idle rate. See full schema in [CLAUDE.md](CLAUDE.md).
-- **Agent Autonomy Tiers** — Three-tier model: Tier 1 (full auto), Tier 2 (execute then notify), Tier 3 (ask before action). Fresh agents default to Tier 3 — safe until you open up autonomy.
-- **Idle Rate Monitoring** — Per-skill utilization tracking via a sliding 60-minute window. Auto-share flips `availability.online: true` when idle rate exceeds 70%.
-- **Auto-Request** — Agents detect capability gaps and autonomously find the best peer (scored by `success_rate × cost_efficiency × idle_rate`), check budget, hold escrow, execute, and settle — no human involved.
-- **Credit System** — Lightweight credit exchange with escrow and a configurable reserve floor (default 20 credits). Auto-request is blocked when balance ≤ reserve.
-- **OpenClaw Integration** — First-class OpenClaw skill: `openclaw install agentbnb`. Sync your SOUL.md to publish a multi-skill card automatically (`agentbnb openclaw sync`).
-- **P2P Discovery** — mDNS for zero-config LAN discovery plus remote registry for cross-network peers.
-- **Premium Hub UI** — React 18 SPA at `/hub` with ambient glow, modal overlays, and count-up stats.
+---
 
 ## Architecture
 
+Built on the [Agent-Native Protocol](./AGENT-NATIVE-PROTOCOL.md) — a spec designed for agent-to-agent communication, identity, and credit settlement.
+
 ```
-agentbnb/
-├── AgentRuntime     Centralized lifecycle: DB ownership, SIGTERM, background jobs
-├── Registry         SQLite + FTS5 store for multi-skill Capability Cards
-├── Gateway          Fastify JSON-RPC server with skill_id routing
-├── Credits          Ledger + escrow + BudgetManager (reserve floor)
-├── Autonomy         Tier classification + IdleMonitor + AutoRequestor
-├── OpenClaw         SOUL.md sync + HEARTBEAT.md rules + skill package
-├── Discovery        mDNS announce/browse for zero-config LAN discovery
-├── Hub              React SPA at /hub — capability browser + owner dashboard
-└── CLI              Commander-based CLI wiring all components
+                    Agent Ecosystems
+                          │
+         ┌────────────────┼────────────────┐
+         │                │                │
+    ┌────┴────┐     ┌────┴────┐     ┌────┴────┐
+    │  MCP    │     │ OpenAPI │     │ Python  │
+    │ Server  │     │  Spec   │     │Adapters │
+    │ (stdio) │     │ + GPT   │     │ LC/Crew │
+    └────┬────┘     └────┬────┘     └────┬────┘
+         │                │                │
+         └────────────────┼────────────────┘
+                          │
+                          ▼
+    ┌─────────────────────────────────────────┐
+    │     Registry + Hub (Fly.io)             │
+    │                                         │
+    │  ┌──────────┐ ┌──────────┐ ┌────────┐  │
+    │  │Card Store│ │  Credit  │ │  Hub   │  │
+    │  │(FTS5)    │ │  Ledger  │ │ Agents │  │
+    │  └────┬─────┘ └────┬─────┘ └───┬────┘  │
+    │       │             │           │       │
+    │  ┌────┴─────────────┴───────────┴────┐  │
+    │  │        WebSocket Relay            │  │
+    │  │  + Job Queue + Relay Bridge       │  │
+    │  │  + Pricing API + Swagger UI       │  │
+    │  └───────────────────────────────────┘  │
+    └─────────────────────────────────────────┘
+              ▲           ▲           ▲
+              │           │           │
+         OpenClaw     Session     Hub Agent
+          Agent       Agent       (always-on)
+        (provider)  (consumer)
 ```
 
-**Agent lifecycle (`agentbnb serve`):**
-1. AgentRuntime opens DB handles (WAL mode), recovers orphaned escrows
-2. Gateway starts listening for incoming JSON-RPC requests
-3. IdleMonitor begins per-skill idle rate polling (60s intervals)
-4. Auto-share flips availability when idle_rate > 70% (respects autonomy tier)
-5. AutoRequestor ready to fill capability gaps on demand
-6. SIGTERM → graceful shutdown of all timers and DB handles
-
-**Credit flow:**
-1. Consumer calls `request` → credits escrowed from balance
-2. Gateway routes to correct skill handler via `skill_id`
-3. Handler responds → escrow settled (credits transferred to provider)
-4. On error → escrow released back to consumer
+---
 
 ## Development
 
 ```bash
 pnpm install          # Install dependencies
-pnpm test:run         # Run all tests
-pnpm test             # Watch mode
+pnpm test:run         # Run all tests (1,001 tests)
 pnpm typecheck        # Type check
-pnpm build            # Build for distribution
-pnpm build:hub        # Build Hub SPA
 pnpm build:all        # Build everything
 ```
 
-## Contributing
+API documentation available at `/docs` (Swagger UI) when running `agentbnb serve`.
+
+---
 
-Contributions welcome. Before proposing a feature, read [AGENT-NATIVE-PROTOCOL.md](AGENT-NATIVE-PROTOCOL.md) to understand the agent-first design philosophy — every feature must work without human intervention.
+## Shape the agent economy.
 
-Open issues on GitHub at [Xiaoher-C/agentbnb](https://github.com/Xiaoher-C/agentbnb). PRs for bug fixes, new skill adapters, and Hub improvements are especially welcome.
+AgentBnB is an open protocol, not a closed platform. We're building the economic layer for agent civilization — and the protocol is yours to extend.
+
+- Read the [Agent-Native Protocol](./AGENT-NATIVE-PROTOCOL.md)
+- Build an adapter for your framework
+- [Open an issue](https://github.com/Xiaoher-C/agentbnb/issues) or start a discussion
+
+The agent economy is coming. The protocols built today will be the rails it runs on.
 
 ---
 
@@ -138,7 +173,3 @@ Open issues on GitHub at [Xiaoher-C/agentbnb](https://github.com/Xiaoher-C/agent
 MIT — see [LICENSE](LICENSE)
 
 © 2026 Cheng Wen Chen
-
----
-
-*Built by Cheng Wen Chen. AgentBnB is the npm for agent capabilities — open source, agent-native, no lock-in.*

package/dist/{card-IE5UV5QX.js → card-4XH4AOTE.js}

@@ -1,15 +1,22 @@
 import {
   CapabilityCardV2Schema
-} from "./chunk-XA63SD4T.js";
+} from "./chunk-FNKBHBYK.js";
 
 // src/conductor/card.ts
+import { createHash } from "crypto";
 var CONDUCTOR_OWNER = "agentbnb-conductor";
 var CONDUCTOR_CARD_ID = "00000000-0000-4000-8000-000000000001";
-function buildConductorCard() {
+function ownerToCardId(owner) {
+  const hash = createHash("sha256").update(owner).digest("hex").slice(0, 32);
+  return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-4${hash.slice(13, 16)}-8${hash.slice(17, 20)}-${hash.slice(20, 32)}`;
+}
+function buildConductorCard(owner) {
+  const cardOwner = owner ?? CONDUCTOR_OWNER;
+  const cardId = owner ? ownerToCardId(owner) : CONDUCTOR_CARD_ID;
   const card = {
     spec_version: "2.0",
-    id: CONDUCTOR_CARD_ID,
-    owner: CONDUCTOR_OWNER,
+    id: cardId,
+    owner: cardOwner,
     agent_name: "AgentBnB Conductor",
     skills: [
       {

package/dist/chunk-3MJT4PZG.js

@@ -0,0 +1,50 @@
+// src/utils/interpolation.ts
+function resolvePath(obj, path) {
+  const segments = path.replace(/\[(\d+)\]/g, ".$1").split(".").filter((s) => s.length > 0);
+  let current = obj;
+  for (const segment of segments) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    if (typeof current !== "object") {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function interpolate(template, context) {
+  return template.replace(/\$\{([^}]+)\}/g, (_match, expression) => {
+    const resolved = resolvePath(context, expression.trim());
+    if (resolved === void 0 || resolved === null) {
+      return "";
+    }
+    if (typeof resolved === "object") {
+      return JSON.stringify(resolved);
+    }
+    return String(resolved);
+  });
+}
+function interpolateObject(obj, context) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    result[key] = interpolateValue(value, context);
+  }
+  return result;
+}
+function interpolateValue(value, context) {
+  if (typeof value === "string") {
+    return interpolate(value, context);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => interpolateValue(item, context));
+  }
+  if (value !== null && typeof value === "object") {
+    return interpolateObject(value, context);
+  }
+  return value;
+}
+
+export {
+  interpolateObject
+};

package/dist/{conduct-IEQ567ET.js → chunk-3UKAVIMC.js}

@@ -4,21 +4,25 @@ import {
   decompose,
   matchSubTasks,
   orchestrate
-} from "./chunk-7OACGAFD.js";
+} from "./chunk-MQKYGY5I.js";
 import {
   BudgetManager
-} from "./chunk-IZZ4FP45.js";
+} from "./chunk-6K5WUVF3.js";
 import {
-  loadConfig,
   loadPeers
-} from "./chunk-BEI5MTNZ.js";
+} from "./chunk-5AH3CMOX.js";
+import {
+  loadConfig
+} from "./chunk-75OC6E4F.js";
 import {
   openDatabase
-} from "./chunk-UOGDK2S2.js";
+} from "./chunk-TLU7ALCZ.js";
 import {
   openCreditDb
-} from "./chunk-QHQPXO67.js";
-import "./chunk-XA63SD4T.js";
+} from "./chunk-XQHN6ITI.js";
+import {
+  RelayClient
+} from "./chunk-JOY533UH.js";
 
 // src/cli/conduct.ts
 async function conductAction(task, opts) {
@@ -34,10 +38,11 @@ async function conductAction(task, opts) {
   const db = openDatabase(config.db_path);
   let matchResults;
   try {
-    matchResults = matchSubTasks({
+    matchResults = await matchSubTasks({
       db,
       subtasks,
-      conductorOwner: config.owner
+      conductorOwner: config.owner,
+      registryUrl: config.registry
     });
   } finally {
     db.close();
@@ -72,33 +77,66 @@ async function conductAction(task, opts) {
     return { success: true, plan: planOutput };
   }
   const peers = loadPeers();
+  const matchMap = new Map(
+    matchResults.map((m) => [m.subtask_id, m])
+  );
   const resolveAgentUrl = (owner) => {
     const peer = peers.find((p) => p.name.toLowerCase() === owner.toLowerCase());
-    if (!peer) {
-      throw new Error(
-        `Unknown peer "${owner}". Add with: agentbnb peers add ${owner} <url> <token>`
-      );
+    if (peer) {
+      const execDb = openDatabase(config.db_path);
+      try {
+        const stmt = execDb.prepare("SELECT id FROM capability_cards WHERE owner = ? LIMIT 1");
+        const row = stmt.get(owner);
+        return { url: peer.url, cardId: row?.id ?? owner };
+      } finally {
+        execDb.close();
+      }
     }
-    const execDb = openDatabase(config.db_path);
-    try {
-      const stmt = execDb.prepare("SELECT id FROM capability_cards WHERE owner = ? LIMIT 1");
-      const row = stmt.get(owner);
-      return { url: peer.url, cardId: row?.id ?? owner };
-    } finally {
-      execDb.close();
+    if (config.registry) {
+      let cardId = owner;
+      for (const m of matchMap.values()) {
+        if (m.selected_agent === owner && m.selected_card_id) {
+          cardId = m.selected_card_id;
+          break;
+        }
+      }
+      return { url: `relay://${owner}`, cardId };
     }
+    throw new Error(
+      `Unknown peer "${owner}". Add with: agentbnb peers add ${owner} <url> <token>`
+    );
   };
-  const matchMap = new Map(
-    matchResults.map((m) => [m.subtask_id, m])
-  );
-  const orchResult = await orchestrate({
-    subtasks,
-    matches: matchMap,
-    gatewayToken: config.token ?? "",
-    resolveAgentUrl,
-    timeoutMs: 3e4,
-    maxBudget
-  });
+  let relay;
+  if (config.registry) {
+    relay = new RelayClient({
+      registryUrl: config.registry,
+      owner: config.owner,
+      token: config.token ?? "",
+      card: { id: config.owner, owner: config.owner, name: "conductor" },
+      onRequest: async () => ({ error: { code: -32601, message: "Conductor does not accept requests" } }),
+      silent: true
+    });
+    try {
+      await relay.connect();
+    } catch {
+      relay = void 0;
+    }
+  }
+  let orchResult;
+  try {
+    orchResult = await orchestrate({
+      subtasks,
+      matches: matchMap,
+      gatewayToken: config.token ?? "",
+      resolveAgentUrl,
+      timeoutMs: 3e5,
+      maxBudget,
+      relayClient: relay,
+      requesterOwner: config.owner
+    });
+  } finally {
+    relay?.disconnect();
+  }
   const resultObj = {};
   for (const [key, value] of orchResult.results) {
     resultObj[key] = value;
@@ -112,6 +150,7 @@ async function conductAction(task, opts) {
     errors: orchResult.errors
   };
 }
+
 export {
   conductAction
 };

package/dist/chunk-5AH3CMOX.js

@@ -0,0 +1,62 @@
+import {
+  getConfigDir
+} from "./chunk-75OC6E4F.js";
+
+// src/cli/peers.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+function getPeersPath() {
+  return join(getConfigDir(), "peers.json");
+}
+function loadPeers() {
+  const peersPath = getPeersPath();
+  if (!existsSync(peersPath)) {
+    return [];
+  }
+  try {
+    const raw = readFileSync(peersPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+function writePeers(peers) {
+  const dir = getConfigDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(getPeersPath(), JSON.stringify(peers, null, 2), "utf-8");
+}
+function savePeer(peer) {
+  const peers = loadPeers();
+  const lowerName = peer.name.toLowerCase();
+  const existing = peers.findIndex((p) => p.name.toLowerCase() === lowerName);
+  if (existing >= 0) {
+    peers[existing] = peer;
+  } else {
+    peers.push(peer);
+  }
+  writePeers(peers);
+}
+function removePeer(name) {
+  const peers = loadPeers();
+  const lowerName = name.toLowerCase();
+  const filtered = peers.filter((p) => p.name.toLowerCase() !== lowerName);
+  if (filtered.length === peers.length) {
+    return false;
+  }
+  writePeers(filtered);
+  return true;
+}
+function findPeer(name) {
+  const peers = loadPeers();
+  const lowerName = name.toLowerCase();
+  return peers.find((p) => p.name.toLowerCase() === lowerName) ?? null;
+}
+
+export {
+  loadPeers,
+  savePeer,
+  removePeer,
+  findPeer
+};