agentbnb 3.1.6 → 4.0.1

package/dist/{peers-G36URZYB.js → peers-K7FSHPN3.js}

@@ -3,7 +3,8 @@ import {
   loadPeers,
   removePeer,
   savePeer
-} from "./chunk-BEI5MTNZ.js";
+} from "./chunk-5AH3CMOX.js";
+import "./chunk-75OC6E4F.js";
 export {
   findPeer,
   loadPeers,

package/dist/request-CNZ3XIVX.js

@@ -0,0 +1,196 @@
+import {
+  createLedger
+} from "./chunk-ODBGCCEH.js";
+import {
+  AutoRequestor,
+  BudgetManager,
+  DEFAULT_AUTONOMY_CONFIG,
+  DEFAULT_BUDGET_CONFIG
+} from "./chunk-6K5WUVF3.js";
+import "./chunk-QJEOCKVF.js";
+import {
+  requestCapability
+} from "./chunk-KJG2UJV5.js";
+import "./chunk-5AH3CMOX.js";
+import "./chunk-75OC6E4F.js";
+import {
+  openDatabase
+} from "./chunk-TLU7ALCZ.js";
+import {
+  openCreditDb
+} from "./chunk-XQHN6ITI.js";
+import {
+  loadKeyPair
+} from "./chunk-DVAS2443.js";
+import "./chunk-FNKBHBYK.js";
+import {
+  RelayClient
+} from "./chunk-JOY533UH.js";
+import "./chunk-QT7TEVNV.js";
+
+// src/mcp/tools/request.ts
+import { z } from "zod";
+var requestInputSchema = {
+  query: z.string().optional().describe("Search query to find a matching capability (auto-request mode)"),
+  card_id: z.string().optional().describe("Direct card ID to request (skips search)"),
+  skill_id: z.string().optional().describe("Specific skill within a v2.0 card"),
+  params: z.record(z.unknown()).optional().describe("Input parameters for the capability"),
+  max_cost: z.number().optional().default(50).describe("Maximum credits to spend")
+};
+async function handleRequest(args, ctx) {
+  try {
+    const maxCost = args.max_cost ?? 50;
+    if (args.query) {
+      const registryDb = openDatabase(ctx.config.db_path);
+      const creditDb = openCreditDb(ctx.config.credit_db_path);
+      registryDb.pragma("busy_timeout = 5000");
+      creditDb.pragma("busy_timeout = 5000");
+      try {
+        const budgetManager = new BudgetManager(
+          creditDb,
+          ctx.config.owner,
+          ctx.config.budget ?? DEFAULT_BUDGET_CONFIG
+        );
+        const requestor = new AutoRequestor({
+          owner: ctx.config.owner,
+          registryDb,
+          creditDb,
+          autonomyConfig: ctx.config.autonomy ?? DEFAULT_AUTONOMY_CONFIG,
+          budgetManager,
+          registryUrl: ctx.config.registry
+        });
+        const result = await requestor.requestWithAutonomy({
+          query: args.query,
+          maxCostCredits: maxCost,
+          params: args.params
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify({ success: true, ...result }, null, 2) }]
+        };
+      } finally {
+        registryDb.close();
+        creditDb.close();
+      }
+    }
+    if (args.card_id) {
+      const cardId = args.card_id;
+      const db = openDatabase(ctx.config.db_path);
+      let localCard;
+      try {
+        const row = db.prepare("SELECT data FROM capability_cards WHERE id = ?").get(cardId);
+        if (row) {
+          localCard = JSON.parse(row.data);
+        }
+      } finally {
+        db.close();
+      }
+      if (localCard) {
+        const result = await requestCapability({
+          gatewayUrl: ctx.config.gateway_url,
+          token: ctx.config.token,
+          cardId,
+          params: { ...args.params ?? {}, ...args.skill_id ? { skill_id: args.skill_id } : {} }
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify({ success: true, result }, null, 2) }]
+        };
+      }
+      if (!ctx.config.registry) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ success: false, error: "Card not found locally and no remote registry configured" }) }]
+        };
+      }
+      const cardUrl = `${ctx.config.registry.replace(/\/$/, "")}/cards/${cardId}`;
+      let remoteCard;
+      try {
+        const resp = await fetch(cardUrl);
+        if (!resp.ok) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ success: false, error: `Card ${cardId} not found on remote registry (${resp.status})` }) }]
+          };
+        }
+        remoteCard = await resp.json();
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Registry unreachable";
+        return {
+          content: [{ type: "text", text: JSON.stringify({ success: false, error: `Cannot reach registry: ${msg}` }) }]
+        };
+      }
+      const targetOwner = remoteCard["owner"] ?? remoteCard["agent_name"];
+      const gatewayUrl = remoteCard["gateway_url"];
+      if (gatewayUrl) {
+        const keys = loadKeyPair(ctx.configDir);
+        const ledger = createLedger({
+          registryUrl: ctx.config.registry,
+          ownerPublicKey: ctx.identity.public_key,
+          privateKey: keys.privateKey
+        });
+        const { escrowId } = await ledger.hold(ctx.config.owner, maxCost, cardId);
+        try {
+          const result = await requestCapability({
+            gatewayUrl,
+            token: "",
+            cardId,
+            params: { ...args.params ?? {}, ...args.skill_id ? { skill_id: args.skill_id } : {} }
+          });
+          await ledger.settle(escrowId, targetOwner ?? "unknown");
+          return {
+            content: [{ type: "text", text: JSON.stringify({ success: true, result, credits_spent: maxCost }, null, 2) }]
+          };
+        } catch (err) {
+          await ledger.release(escrowId);
+          throw err;
+        }
+      }
+      if (targetOwner) {
+        const relay = new RelayClient({
+          registryUrl: ctx.config.registry,
+          owner: ctx.config.owner,
+          token: ctx.config.token ?? "",
+          card: { id: ctx.config.owner, owner: ctx.config.owner, name: "mcp-requester" },
+          onRequest: async () => ({ error: { code: -32601, message: "MCP client does not accept requests" } }),
+          silent: true
+        });
+        try {
+          await relay.connect();
+          const result = await relay.request({
+            targetOwner,
+            cardId,
+            skillId: args.skill_id,
+            params: args.params ?? {},
+            requester: ctx.config.owner,
+            timeoutMs: 3e5
+          });
+          return {
+            content: [{ type: "text", text: JSON.stringify({ success: true, result }, null, 2) }]
+          };
+        } finally {
+          relay.disconnect();
+        }
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify({ success: false, error: "Remote card has no gateway_url and no owner for relay routing" }) }]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify({ success: false, error: "Provide either query or card_id" }) }]
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error during request";
+    return {
+      content: [{ type: "text", text: JSON.stringify({ success: false, error: message }) }]
+    };
+  }
+}
+function registerRequestTool(server, ctx) {
+  server.registerTool("agentbnb_request", {
+    description: "Request execution of a skill from another agent on the AgentBnB network. Handles credit escrow automatically.",
+    inputSchema: requestInputSchema
+  }, async (args) => {
+    return handleRequest(args, ctx);
+  });
+}
+export {
+  handleRequest,
+  registerRequestTool
+};

package/dist/serve-skill-SUOGUM7N.js

@@ -0,0 +1,104 @@
+import {
+  executeCapabilityRequest
+} from "./chunk-Q7HRI666.js";
+import {
+  listCards,
+  openDatabase
+} from "./chunk-TLU7ALCZ.js";
+import {
+  openCreditDb
+} from "./chunk-XQHN6ITI.js";
+import "./chunk-DVAS2443.js";
+import "./chunk-FNKBHBYK.js";
+import {
+  RelayClient
+} from "./chunk-JOY533UH.js";
+import "./chunk-QT7TEVNV.js";
+
+// src/mcp/tools/serve-skill.ts
+import { z } from "zod";
+var serveSkillInputSchema = {
+  handler_url: z.string().optional().default("http://localhost:8080").describe("Local URL that handles capability execution"),
+  skills_yaml: z.string().optional().describe("Path to skills.yaml config file")
+};
+async function handleServeSkill(args, ctx) {
+  try {
+    if (!ctx.config.registry) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ success: false, error: "No remote registry configured. Set one with: agentbnb config set registry <url>" }) }]
+      };
+    }
+    const db = openDatabase(ctx.config.db_path);
+    let cards;
+    try {
+      cards = listCards(db, ctx.config.owner);
+    } finally {
+      db.close();
+    }
+    if (cards.length === 0) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ success: false, error: "No capability cards found. Publish a card first with agentbnb_publish." }) }]
+      };
+    }
+    const card = cards[0];
+    const handlerUrl = args.handler_url ?? "http://localhost:8080";
+    const relay = new RelayClient({
+      registryUrl: ctx.config.registry,
+      owner: ctx.config.owner,
+      token: ctx.config.token ?? "",
+      card,
+      onRequest: async (req) => {
+        const registryDb = openDatabase(ctx.config.db_path);
+        const creditDb = openCreditDb(ctx.config.credit_db_path);
+        try {
+          const result = await executeCapabilityRequest({
+            registryDb,
+            creditDb,
+            cardId: req.params?.card_id ?? card.id,
+            skillId: req.params?.skill_id,
+            params: req.params?.params ?? {},
+            requester: req.params?.requester ?? "unknown",
+            handlerUrl
+          });
+          if (result.success) {
+            return { result: result.result };
+          }
+          return { error: result.error };
+        } finally {
+          registryDb.close();
+          creditDb.close();
+        }
+      },
+      silent: true
+    });
+    await relay.connect();
+    ctx.relayClient = relay;
+    return {
+      content: [{ type: "text", text: JSON.stringify({
+        success: true,
+        message: "Connected to relay as provider",
+        owner: ctx.config.owner,
+        registry_url: ctx.config.registry,
+        card_id: card.id,
+        handler_url: handlerUrl
+      }, null, 2) }]
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error during serve_skill";
+    return {
+      content: [{ type: "text", text: JSON.stringify({ success: false, error: message }) }]
+    };
+  }
+}
+function registerServeSkillTool(server, ctx) {
+  server.registerTool("agentbnb_serve_skill", {
+    description: "Register as a skill provider on the AgentBnB network via relay. Connects to the registry and listens for incoming skill requests.",
+    inputSchema: serveSkillInputSchema
+  }, async (args) => {
+    return handleServeSkill(args, ctx);
+  });
+}
+export {
+  handleServeSkill,
+  registerServeSkillTool
+};

package/dist/server-2LWHL24P.js

@@ -0,0 +1,295 @@
+import {
+  ensureIdentity
+} from "./chunk-M3G5NR2Z.js";
+import {
+  createLedger
+} from "./chunk-ODBGCCEH.js";
+import {
+  fetchRemoteCards,
+  mergeResults,
+  searchCards
+} from "./chunk-QJEOCKVF.js";
+import {
+  getConfigDir,
+  loadConfig
+} from "./chunk-75OC6E4F.js";
+import {
+  insertCard,
+  openDatabase
+} from "./chunk-TLU7ALCZ.js";
+import {
+  getBalance,
+  openCreditDb
+} from "./chunk-XQHN6ITI.js";
+import {
+  loadKeyPair
+} from "./chunk-DVAS2443.js";
+import {
+  AnyCardSchema
+} from "./chunk-FNKBHBYK.js";
+
+// src/mcp/server.ts
+import { createRequire } from "module";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/mcp/tools/discover.ts
+import { z } from "zod";
+var discoverInputSchema = {
+  query: z.string().describe("Natural language search query"),
+  level: z.number().optional().describe("Filter by capability level (1=Atomic, 2=Pipeline, 3=Environment)"),
+  online_only: z.boolean().optional().describe("Only show online agents")
+};
+async function handleDiscover(args, ctx) {
+  try {
+    const db = openDatabase(ctx.config.db_path);
+    let localCards;
+    try {
+      localCards = searchCards(db, args.query, {
+        level: args.level,
+        online: args.online_only
+      });
+    } finally {
+      db.close();
+    }
+    let remoteCards = [];
+    if (ctx.config.registry) {
+      try {
+        remoteCards = await fetchRemoteCards(ctx.config.registry, {
+          q: args.query,
+          level: args.level,
+          online: args.online_only
+        });
+      } catch {
+      }
+    }
+    const merged = mergeResults(localCards, remoteCards, true);
+    const results = merged.map((card) => {
+      const raw = card;
+      const skills = Array.isArray(raw["skills"]) ? raw["skills"].map((s) => ({
+        id: s.id,
+        name: s.name,
+        description: s.description,
+        credits_per_call: s.pricing.credits_per_call
+      })) : void 0;
+      return {
+        id: card.id,
+        name: card.name,
+        owner: card.owner,
+        description: card.description,
+        level: card.level,
+        skills,
+        pricing: card.pricing,
+        source: card.source,
+        online: card.availability?.online ?? false
+      };
+    });
+    return {
+      content: [{ type: "text", text: JSON.stringify({ results, count: results.length }, null, 2) }]
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error during discover";
+    return {
+      content: [{ type: "text", text: JSON.stringify({ success: false, error: message }) }]
+    };
+  }
+}
+function registerDiscoverTool(server, ctx) {
+  server.registerTool("agentbnb_discover", {
+    description: "Search for agent capabilities on the AgentBnB network. Returns matching capability cards from both local and remote registries.",
+    inputSchema: discoverInputSchema
+  }, async (args) => {
+    return handleDiscover(args, ctx);
+  });
+}
+
+// src/mcp/tools/status.ts
+import { z as z2 } from "zod";
+var statusInputSchema = {
+  _unused: z2.string().optional().describe("No parameters needed")
+};
+async function handleStatus(ctx) {
+  try {
+    let balance = 0;
+    if (ctx.config.registry) {
+      try {
+        const keys = loadKeyPair(ctx.configDir);
+        const ledger = createLedger({
+          registryUrl: ctx.config.registry,
+          ownerPublicKey: ctx.identity.public_key,
+          privateKey: keys.privateKey
+        });
+        balance = await ledger.getBalance(ctx.identity.owner);
+      } catch {
+        const creditDb = openCreditDb(ctx.config.credit_db_path);
+        try {
+          balance = getBalance(creditDb, ctx.identity.owner);
+        } finally {
+          creditDb.close();
+        }
+      }
+    } else {
+      const creditDb = openCreditDb(ctx.config.credit_db_path);
+      try {
+        balance = getBalance(creditDb, ctx.identity.owner);
+      } finally {
+        creditDb.close();
+      }
+    }
+    const result = {
+      agent_id: ctx.identity.agent_id,
+      owner: ctx.identity.owner,
+      public_key: ctx.identity.public_key,
+      balance,
+      registry_url: ctx.config.registry ?? null,
+      config_dir: ctx.configDir
+    };
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error during status check";
+    return {
+      content: [{ type: "text", text: JSON.stringify({ success: false, error: message }) }]
+    };
+  }
+}
+function registerStatusTool(server, ctx) {
+  server.registerTool("agentbnb_status", {
+    description: "Check your AgentBnB agent status: identity, credit balance, and configuration.",
+    inputSchema: statusInputSchema
+  }, async () => {
+    return handleStatus(ctx);
+  });
+}
+
+// src/mcp/tools/publish.ts
+import { z as z3 } from "zod";
+var publishInputSchema = {
+  card_json: z3.string().describe("JSON string of the capability card to publish")
+};
+async function handlePublish(args, ctx) {
+  try {
+    let parsed;
+    try {
+      parsed = JSON.parse(args.card_json);
+    } catch {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ success: false, error: "Invalid JSON in card_json" }) }]
+      };
+    }
+    const validated = AnyCardSchema.safeParse(parsed);
+    if (!validated.success) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ success: false, error: "Card validation failed", details: validated.error.issues }) }]
+      };
+    }
+    const card = validated.data;
+    const rawCard = card;
+    if (Array.isArray(rawCard["skills"])) {
+      const skills = rawCard["skills"];
+      for (const skill of skills) {
+        if (skill.pricing.credits_per_call < 1) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ success: false, error: "Minimum price is 1 credit per call for each skill" }) }]
+          };
+        }
+      }
+    } else {
+      const pricing = rawCard["pricing"];
+      if (pricing && pricing.credits_per_call < 1) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ success: false, error: "Minimum price is 1 credit per call" }) }]
+        };
+      }
+    }
+    const db = openDatabase(ctx.config.db_path);
+    try {
+      insertCard(db, card);
+    } finally {
+      db.close();
+    }
+    let remotePublished = false;
+    if (ctx.config.registry) {
+      try {
+        const publishUrl = new URL("/cards", ctx.config.registry);
+        const body = {
+          ...card,
+          gateway_url: ctx.config.gateway_url
+        };
+        const res = await fetch(publishUrl.toString(), {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        remotePublished = res.ok;
+      } catch {
+      }
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify({
+        success: true,
+        card_id: card.id,
+        card_name: rawCard["name"] ?? rawCard["agent_name"] ?? card.id,
+        remote_published: remotePublished
+      }, null, 2) }]
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error during publish";
+    return {
+      content: [{ type: "text", text: JSON.stringify({ success: false, error: message }) }]
+    };
+  }
+}
+function registerPublishTool(server, ctx) {
+  server.registerTool("agentbnb_publish", {
+    description: "Publish a capability card to the AgentBnB network. Stores locally and optionally syncs to remote registry.",
+    inputSchema: publishInputSchema
+  }, async (args) => {
+    return handlePublish(args, ctx);
+  });
+}
+
+// src/mcp/server.ts
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../../package.json");
+async function startMcpServer() {
+  const config = loadConfig();
+  if (!config) {
+    process.stderr.write("Error: AgentBnB not initialized. Run `agentbnb init` first.\n");
+    process.exit(1);
+  }
+  const configDir = getConfigDir();
+  const identity = ensureIdentity(configDir, config.owner);
+  const server = new McpServer({
+    name: "agentbnb",
+    version: pkg.version
+  });
+  const ctx = {
+    configDir,
+    config,
+    identity
+  };
+  registerDiscoverTool(server, ctx);
+  registerStatusTool(server, ctx);
+  registerPublishTool(server, ctx);
+  const { registerRequestTool } = await import("./request-CNZ3XIVX.js");
+  const { registerConductTool } = await import("./conduct-CW62HBPT.js");
+  const { registerServeSkillTool } = await import("./serve-skill-SUOGUM7N.js");
+  registerRequestTool(server, ctx);
+  registerConductTool(server, ctx);
+  registerServeSkillTool(server, ctx);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.stderr.write(`AgentBnB MCP server started (owner: ${identity.owner})
+`);
+  const shutdown = () => {
+    ctx.relayClient?.disconnect();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+export {
+  startMcpServer
+};

package/dist/types-FGBUZ3QV.js

@@ -0,0 +1,18 @@
+import {
+  AgentBnBError,
+  AnyCardSchema,
+  CapabilityCardSchema,
+  CapabilityCardV2Schema,
+  IOSchemaSchema,
+  PoweredBySchema,
+  SkillSchema
+} from "./chunk-FNKBHBYK.js";
+export {
+  AgentBnBError,
+  AnyCardSchema,
+  CapabilityCardSchema,
+  CapabilityCardV2Schema,
+  IOSchemaSchema,
+  PoweredBySchema,
+  SkillSchema
+};

package/dist/websocket-client-6IIDGXKB.js

@@ -0,0 +1,7 @@
+import {
+  RelayClient
+} from "./chunk-JOY533UH.js";
+import "./chunk-QT7TEVNV.js";
+export {
+  RelayClient
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentbnb",
-  "version": "3.1.6",
+  "version": "4.0.1",
   "description": "P2P Agent Capability Sharing Protocol — Airbnb for AI agent pipelines",
   "type": "module",
   "main": "dist/index.js",
@@ -68,7 +68,10 @@
   "dependencies": {
     "@fastify/cors": "^11.2.0",
     "@fastify/static": "^9.0.0",
+    "@fastify/swagger": "^9.7.0",
+    "@fastify/swagger-ui": "^5.2.5",
     "@fastify/websocket": "^11.2.0",
+    "@modelcontextprotocol/sdk": "^1.27.1",
     "better-sqlite3": "^11.6.0",
     "bonjour-service": "^1.3.0",
     "commander": "^12.1.0",