agentbnb 4.0.2 → 4.0.4

package/README.md

@@ -17,7 +17,7 @@
 ## Get started in one command
 
 ```bash
-openclaw install agentbnb
+openclaw plugins install agentbnb
 ```
 
 Your agent joins the network, shares its idle skills, and earns credits from peers. Use those credits to access capabilities your agent never had.
@@ -27,7 +27,7 @@ Your agent joins the network, shares its idle skills, and earns credits from pee
 
 | Tool | Command |
 |------|---------|
-| **OpenClaw** | `openclaw install agentbnb` |
+| **OpenClaw** | `openclaw plugins 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` |
@@ -62,6 +62,35 @@ Read the full design philosophy in [AGENT-NATIVE-PROTOCOL.md](AGENT-NATIVE-PROTO
 
 ---
 
+## First cross-machine transaction — live proof
+
+On 2026-03-21, two physical machines completed a full E2E trade over the public relay:
+
+```
+Machine 2 (agent-2a44d8f0)          hub.agentbnb.dev              Machine 1 (Xiaoher-C)
+         │                                  │                              │
+         │  agentbnb request --cost 5       │                              │
+         │ ─────────────────────────────►   │                              │
+         │                                  │  hold 5 credits (escrow)     │
+         │                                  │  ──────────────────────────► │
+         │                                  │  incoming_request            │
+         │                                  │ ────────────────────────────►│
+         │                                  │          ElevenLabs TTS API  │
+         │                                  │                         ◄────│
+         │                                  │  relay_response (audio_base64│
+         │                                  │ ◄────────────────────────────│
+         │                                  │  settle 5 credits → Xiaoher-C│
+         │  result: { audio_base64: "..." } │                              │
+         │ ◄─────────────────────────────── │                              │
+```
+
+- **No shared infrastructure** between the two machines — only the public relay
+- **Credits moved**: 5 credits from `agent-2a44d8f0` → escrowed → settled to `Xiaoher-C`
+- **Skill executed**: ElevenLabs TTS via `CommandExecutor` on Machine 1
+- **Result**: MP3 audio delivered as base64 to Machine 2
+
+---
+
 ## Agent Hub
 
 <p align="center">

package/dist/card-RNEWSAQ6.js

@@ -0,0 +1,88 @@
+import {
+  CapabilityCardV2Schema
+} from "./chunk-UB2NPFC7.js";
+
+// src/conductor/card.ts
+import { createHash } from "crypto";
+var CONDUCTOR_OWNER = "agentbnb-conductor";
+var CONDUCTOR_CARD_ID = "00000000-0000-4000-8000-000000000001";
+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: cardId,
+    owner: cardOwner,
+    agent_name: "AgentBnB Conductor",
+    skills: [
+      {
+        id: "orchestrate",
+        name: "Task Orchestration",
+        description: "Decomposes complex tasks and coordinates multi-agent execution",
+        level: 3,
+        inputs: [
+          {
+            name: "task",
+            type: "text",
+            description: "Natural language task description"
+          }
+        ],
+        outputs: [
+          {
+            name: "result",
+            type: "json",
+            description: "Aggregated execution results"
+          }
+        ],
+        pricing: { credits_per_call: 5 }
+      },
+      {
+        id: "plan",
+        name: "Execution Planning",
+        description: "Returns an execution plan with cost estimate without executing",
+        level: 1,
+        inputs: [
+          {
+            name: "task",
+            type: "text",
+            description: "Natural language task description"
+          }
+        ],
+        outputs: [
+          {
+            name: "plan",
+            type: "json",
+            description: "Execution plan with cost breakdown"
+          }
+        ],
+        pricing: { credits_per_call: 1 }
+      }
+    ],
+    availability: { online: true }
+  };
+  return CapabilityCardV2Schema.parse(card);
+}
+function registerConductorCard(db) {
+  const card = buildConductorCard();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = db.prepare("SELECT id FROM capability_cards WHERE id = ?").get(card.id);
+  if (existing) {
+    db.prepare(
+      "UPDATE capability_cards SET data = ?, updated_at = ? WHERE id = ?"
+    ).run(JSON.stringify(card), now, card.id);
+  } else {
+    db.prepare(
+      "INSERT INTO capability_cards (id, owner, data, created_at, updated_at) VALUES (?, ?, ?, ?, ?)"
+    ).run(card.id, card.owner, JSON.stringify(card), now, now);
+  }
+  return card;
+}
+export {
+  CONDUCTOR_OWNER,
+  buildConductorCard,
+  registerConductorCard
+};

package/dist/{chunk-7NA43XCG.js → chunk-5QGXARLJ.js}

@@ -52,7 +52,8 @@ async function executeCapabilityRequest(opts) {
     skillExecutor,
     handlerUrl,
     timeoutMs = 3e5,
-    onProgress
+    onProgress,
+    relayAuthorized = false
   } = opts;
   const card = getCard(registryDb, cardId);
   if (!card) {
@@ -77,7 +78,8 @@ async function executeCapabilityRequest(opts) {
   }
   let escrowId = null;
   let isRemoteEscrow = false;
-  if (receipt) {
+  if (relayAuthorized) {
+  } else if (receipt) {
     const { signature, ...receiptData2 } = receipt;
     const publicKeyBuf = Buffer.from(receipt.requester_public_key, "hex");
     const valid = verifyEscrowReceipt(receiptData2, signature, publicKeyBuf);

package/dist/chunk-EVBX22YU.js

@@ -0,0 +1,68 @@
+// src/cli/peers.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/cli/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function getConfigDir() {
+  return process.env["AGENTBNB_DIR"] ?? join(homedir(), ".agentbnb");
+}
+
+// src/cli/peers.ts
+function getPeersPath() {
+  return join2(getConfigDir(), "peers.json");
+}
+function loadPeers() {
+  const peersPath = getPeersPath();
+  if (!existsSync2(peersPath)) {
+    return [];
+  }
+  try {
+    const raw = readFileSync2(peersPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+function writePeers(peers) {
+  const dir = getConfigDir();
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  writeFileSync2(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
+};

package/dist/chunk-JXEOE7HX.js

@@ -0,0 +1,295 @@
+import {
+  AgentBnBError
+} from "./chunk-UB2NPFC7.js";
+
+// src/autonomy/tiers.ts
+import { randomUUID } from "crypto";
+var DEFAULT_AUTONOMY_CONFIG = {
+  tier1_max_credits: 0,
+  tier2_max_credits: 0
+};
+function getAutonomyTier(creditAmount, config) {
+  if (creditAmount < config.tier1_max_credits) return 1;
+  if (creditAmount < config.tier2_max_credits) return 2;
+  return 3;
+}
+function insertAuditEvent(db, event) {
+  const isShareEvent = event.type === "auto_share" || event.type === "auto_share_notify" || event.type === "auto_share_pending";
+  const cardId = isShareEvent ? "system" : event.card_id;
+  const creditsCharged = isShareEvent ? 0 : event.credits;
+  const stmt = db.prepare(`
+    INSERT INTO request_log (
+      id, card_id, card_name, requester, status, latency_ms, credits_charged,
+      created_at, skill_id, action_type, tier_invoked
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  stmt.run(
+    randomUUID(),
+    cardId,
+    "autonomy-audit",
+    "self",
+    "success",
+    0,
+    creditsCharged,
+    (/* @__PURE__ */ new Date()).toISOString(),
+    event.skill_id,
+    event.type,
+    event.tier_invoked
+  );
+}
+
+// src/credit/ledger.ts
+import Database from "better-sqlite3";
+import { randomUUID as randomUUID2 } from "crypto";
+var CREDIT_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS credit_balances (
+    owner TEXT PRIMARY KEY,
+    balance INTEGER NOT NULL DEFAULT 0,
+    updated_at TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS credit_transactions (
+    id TEXT PRIMARY KEY,
+    owner TEXT NOT NULL,
+    amount INTEGER NOT NULL,
+    reason TEXT NOT NULL,
+    reference_id TEXT,
+    created_at TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS credit_escrow (
+    id TEXT PRIMARY KEY,
+    owner TEXT NOT NULL,
+    amount INTEGER NOT NULL,
+    card_id TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'held',
+    created_at TEXT NOT NULL,
+    settled_at TEXT
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_transactions_owner ON credit_transactions(owner, created_at);
+  CREATE INDEX IF NOT EXISTS idx_escrow_owner ON credit_escrow(owner);
+`;
+function openCreditDb(path = ":memory:") {
+  const db = new Database(path);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(CREDIT_SCHEMA);
+  return db;
+}
+function getBalance(db, owner) {
+  const row = db.prepare("SELECT balance FROM credit_balances WHERE owner = ?").get(owner);
+  return row?.balance ?? 0;
+}
+function recordEarning(db, owner, amount, _cardId, receiptNonce) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.transaction(() => {
+    const existing = db.prepare(
+      "SELECT id FROM credit_transactions WHERE reference_id = ? AND reason = 'remote_earning'"
+    ).get(receiptNonce);
+    if (existing) return;
+    db.prepare(
+      "INSERT OR IGNORE INTO credit_balances (owner, balance, updated_at) VALUES (?, 0, ?)"
+    ).run(owner, now);
+    db.prepare(
+      "UPDATE credit_balances SET balance = balance + ?, updated_at = ? WHERE owner = ?"
+    ).run(amount, now, owner);
+    db.prepare(
+      "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+    ).run(randomUUID2(), owner, amount, "remote_earning", receiptNonce, now);
+  })();
+}
+
+// src/credit/escrow.ts
+import { randomUUID as randomUUID3 } from "crypto";
+function holdEscrow(db, owner, amount, cardId) {
+  const escrowId = randomUUID3();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const hold = db.transaction(() => {
+    const row = db.prepare("SELECT balance FROM credit_balances WHERE owner = ?").get(owner);
+    if (!row || row.balance < amount) {
+      throw new AgentBnBError("Insufficient credits", "INSUFFICIENT_CREDITS");
+    }
+    db.prepare(
+      "UPDATE credit_balances SET balance = balance - ?, updated_at = ? WHERE owner = ? AND balance >= ?"
+    ).run(amount, now, owner, amount);
+    db.prepare(
+      "INSERT INTO credit_escrow (id, owner, amount, card_id, status, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+    ).run(escrowId, owner, amount, cardId, "held", now);
+    db.prepare(
+      "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+    ).run(randomUUID3(), owner, -amount, "escrow_hold", escrowId, now);
+  });
+  hold();
+  return escrowId;
+}
+function settleEscrow(db, escrowId, recipientOwner) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const settle = db.transaction(() => {
+    const escrow = db.prepare("SELECT id, owner, amount, status FROM credit_escrow WHERE id = ?").get(escrowId);
+    if (!escrow) {
+      throw new AgentBnBError(`Escrow not found: ${escrowId}`, "ESCROW_NOT_FOUND");
+    }
+    if (escrow.status !== "held") {
+      throw new AgentBnBError(
+        `Escrow ${escrowId} is already ${escrow.status}`,
+        "ESCROW_ALREADY_SETTLED"
+      );
+    }
+    db.prepare(
+      "INSERT OR IGNORE INTO credit_balances (owner, balance, updated_at) VALUES (?, 0, ?)"
+    ).run(recipientOwner, now);
+    db.prepare(
+      "UPDATE credit_balances SET balance = balance + ?, updated_at = ? WHERE owner = ?"
+    ).run(escrow.amount, now, recipientOwner);
+    db.prepare(
+      "UPDATE credit_escrow SET status = ?, settled_at = ? WHERE id = ?"
+    ).run("settled", now, escrowId);
+    db.prepare(
+      "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+    ).run(randomUUID3(), recipientOwner, escrow.amount, "settlement", escrowId, now);
+  });
+  settle();
+}
+function releaseEscrow(db, escrowId) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const release = db.transaction(() => {
+    const escrow = db.prepare("SELECT id, owner, amount, status FROM credit_escrow WHERE id = ?").get(escrowId);
+    if (!escrow) {
+      throw new AgentBnBError(`Escrow not found: ${escrowId}`, "ESCROW_NOT_FOUND");
+    }
+    if (escrow.status !== "held") {
+      throw new AgentBnBError(
+        `Escrow ${escrowId} is already ${escrow.status}`,
+        "ESCROW_ALREADY_SETTLED"
+      );
+    }
+    db.prepare(
+      "UPDATE credit_balances SET balance = balance + ?, updated_at = ? WHERE owner = ?"
+    ).run(escrow.amount, now, escrow.owner);
+    db.prepare(
+      "UPDATE credit_escrow SET status = ?, settled_at = ? WHERE id = ?"
+    ).run("released", now, escrowId);
+    db.prepare(
+      "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+    ).run(randomUUID3(), escrow.owner, escrow.amount, "refund", escrowId, now);
+  });
+  release();
+}
+
+// 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;
+}
+
+// src/credit/signing.ts
+import { generateKeyPairSync, sign, verify, createPublicKey, createPrivateKey } from "crypto";
+import { writeFileSync, readFileSync, existsSync, chmodSync } from "fs";
+import { join } from "path";
+function generateKeyPair() {
+  const { publicKey, privateKey } = generateKeyPairSync("ed25519", {
+    publicKeyEncoding: { type: "spki", format: "der" },
+    privateKeyEncoding: { type: "pkcs8", format: "der" }
+  });
+  return {
+    publicKey: Buffer.from(publicKey),
+    privateKey: Buffer.from(privateKey)
+  };
+}
+function saveKeyPair(configDir, keys) {
+  const privatePath = join(configDir, "private.key");
+  const publicPath = join(configDir, "public.key");
+  writeFileSync(privatePath, keys.privateKey);
+  chmodSync(privatePath, 384);
+  writeFileSync(publicPath, keys.publicKey);
+}
+function loadKeyPair(configDir) {
+  const privatePath = join(configDir, "private.key");
+  const publicPath = join(configDir, "public.key");
+  if (!existsSync(privatePath) || !existsSync(publicPath)) {
+    throw new AgentBnBError("Keypair not found. Run `agentbnb init` to generate one.", "KEYPAIR_NOT_FOUND");
+  }
+  return {
+    publicKey: readFileSync(publicPath),
+    privateKey: readFileSync(privatePath)
+  };
+}
+function canonicalJson(data) {
+  return JSON.stringify(data, Object.keys(data).sort());
+}
+function signEscrowReceipt(data, privateKey) {
+  const message = Buffer.from(canonicalJson(data), "utf-8");
+  const keyObject = createPrivateKey({ key: privateKey, format: "der", type: "pkcs8" });
+  const signature = sign(null, message, keyObject);
+  return signature.toString("base64url");
+}
+function verifyEscrowReceipt(data, signature, publicKey) {
+  try {
+    const message = Buffer.from(canonicalJson(data), "utf-8");
+    const keyObject = createPublicKey({ key: publicKey, format: "der", type: "spki" });
+    const sigBuffer = Buffer.from(signature, "base64url");
+    return verify(null, message, keyObject, sigBuffer);
+  } catch {
+    return false;
+  }
+}
+
+export {
+  openCreditDb,
+  getBalance,
+  recordEarning,
+  holdEscrow,
+  settleEscrow,
+  releaseEscrow,
+  interpolateObject,
+  generateKeyPair,
+  saveKeyPair,
+  loadKeyPair,
+  signEscrowReceipt,
+  verifyEscrowReceipt,
+  DEFAULT_AUTONOMY_CONFIG,
+  getAutonomyTier,
+  insertAuditEvent
+};

package/dist/chunk-UB2NPFC7.js

@@ -0,0 +1,165 @@
+// src/types/index.ts
+import { z } from "zod";
+var IOSchemaSchema = z.object({
+  name: z.string(),
+  type: z.enum(["text", "json", "file", "audio", "image", "video", "stream"]),
+  description: z.string().optional(),
+  required: z.boolean().default(true),
+  schema: z.record(z.unknown()).optional()
+  // JSON Schema
+});
+var PoweredBySchema = z.object({
+  provider: z.string().min(1),
+  model: z.string().optional(),
+  tier: z.string().optional()
+});
+var CapabilityCardSchema = z.object({
+  spec_version: z.literal("1.0").default("1.0"),
+  id: z.string().uuid(),
+  owner: z.string().min(1),
+  name: z.string().min(1).max(100),
+  description: z.string().max(500),
+  level: z.union([z.literal(1), z.literal(2), z.literal(3)]),
+  inputs: z.array(IOSchemaSchema),
+  outputs: z.array(IOSchemaSchema),
+  pricing: z.object({
+    credits_per_call: z.number().nonnegative(),
+    credits_per_minute: z.number().nonnegative().optional(),
+    /** Number of free monthly calls. Shown as a "N free/mo" badge in the Hub. */
+    free_tier: z.number().nonnegative().optional()
+  }),
+  availability: z.object({
+    online: z.boolean(),
+    schedule: z.string().optional()
+    // cron expression
+  }),
+  powered_by: z.array(PoweredBySchema).optional(),
+  /**
+   * Private per-card metadata. Stripped from all API and CLI responses —
+   * never transmitted beyond the local store.
+   */
+  _internal: z.record(z.unknown()).optional(),
+  /** Public gateway URL where this agent accepts requests. Populated on remote publish. */
+  gateway_url: z.string().url().optional(),
+  metadata: z.object({
+    apis_used: z.array(z.string()).optional(),
+    avg_latency_ms: z.number().nonnegative().optional(),
+    success_rate: z.number().min(0).max(1).optional(),
+    tags: z.array(z.string()).optional()
+  }).optional(),
+  created_at: z.string().datetime().optional(),
+  updated_at: z.string().datetime().optional()
+});
+var SkillSchema = z.object({
+  /** Stable skill identifier, e.g. 'tts-elevenlabs'. Used for gateway routing and idle tracking. */
+  id: z.string().min(1),
+  name: z.string().min(1).max(100),
+  description: z.string().max(500),
+  level: z.union([z.literal(1), z.literal(2), z.literal(3)]),
+  /** Optional grouping category, e.g. 'tts' | 'video_gen' | 'code_review'. */
+  category: z.string().optional(),
+  inputs: z.array(IOSchemaSchema),
+  outputs: z.array(IOSchemaSchema),
+  pricing: z.object({
+    credits_per_call: z.number().nonnegative(),
+    credits_per_minute: z.number().nonnegative().optional(),
+    free_tier: z.number().nonnegative().optional()
+  }),
+  /** Per-skill online flag — overrides card-level availability for this skill. */
+  availability: z.object({ online: z.boolean() }).optional(),
+  powered_by: z.array(PoweredBySchema).optional(),
+  metadata: z.object({
+    apis_used: z.array(z.string()).optional(),
+    avg_latency_ms: z.number().nonnegative().optional(),
+    success_rate: z.number().min(0).max(1).optional(),
+    tags: z.array(z.string()).optional(),
+    capacity: z.object({
+      calls_per_hour: z.number().positive().default(60)
+    }).optional()
+  }).optional(),
+  /**
+   * Private per-skill metadata. Stripped from all API and CLI responses —
+   * never transmitted beyond the local store.
+   */
+  _internal: z.record(z.unknown()).optional()
+});
+var SuitabilitySchema = z.object({
+  /** Use cases this agent/skill is optimised for. */
+  ideal_for: z.array(z.string()).optional(),
+  /** Scenarios this agent/skill cannot reliably handle. */
+  not_suitable_for: z.array(z.string()).optional(),
+  /** Domains explicitly excluded (used for routing exclusions in later phases). */
+  excluded_domains: z.array(z.string()).optional(),
+  /** Conditions that increase failure risk, shown as warnings in the Hub. */
+  risk_conditions: z.array(z.string()).optional(),
+  /** Recommended alternative when this agent is unsuitable. */
+  fallback_recommendation: z.string().optional()
+});
+var LearningSchema = z.object({
+  /** Known limitations that may affect reliability (self-declared). */
+  known_limitations: z.array(z.string()).optional(),
+  /** Common failure patterns observed by the provider. */
+  common_failure_patterns: z.array(z.string()).optional(),
+  /** Version-tagged improvements the provider has shipped. */
+  recent_improvements: z.array(z.object({
+    version: z.string(),
+    summary: z.string(),
+    timestamp: z.string()
+  })).optional(),
+  /** Structured critiques from external sources (phase 2+). */
+  critiques: z.array(z.object({
+    type: z.literal("structured"),
+    summary: z.string(),
+    source_tier: z.string(),
+    timestamp: z.string()
+  })).optional()
+});
+var CapabilityCardV2Schema = z.object({
+  spec_version: z.literal("2.0"),
+  id: z.string().uuid(),
+  owner: z.string().min(1),
+  /** Agent display name — was 'name' in v1.0. */
+  agent_name: z.string().min(1).max(100),
+  /** Short one-liner shown in Hub v2 Identity Header. */
+  short_description: z.string().max(200).optional(),
+  /** At least one skill is required. */
+  skills: z.array(SkillSchema).min(1),
+  availability: z.object({
+    online: z.boolean(),
+    schedule: z.string().optional()
+  }),
+  /** Optional deployment environment metadata. */
+  environment: z.object({
+    runtime: z.string(),
+    region: z.string().optional()
+  }).optional(),
+  /** Suitability metadata for Hub v2 profile and future routing warnings. */
+  suitability: SuitabilitySchema.optional(),
+  /** Learning signals — self-declared limitations, improvements, critiques. */
+  learning: LearningSchema.optional(),
+  /**
+   * Private per-card metadata. Stripped from all API and CLI responses —
+   * never transmitted beyond the local store.
+   */
+  _internal: z.record(z.unknown()).optional(),
+  /** Public gateway URL where this agent accepts requests. Populated on remote publish. */
+  gateway_url: z.string().url().optional(),
+  created_at: z.string().datetime().optional(),
+  updated_at: z.string().datetime().optional()
+});
+var AnyCardSchema = z.discriminatedUnion("spec_version", [
+  CapabilityCardSchema,
+  CapabilityCardV2Schema
+]);
+var AgentBnBError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "AgentBnBError";
+  }
+};
+
+export {
+  CapabilityCardV2Schema,
+  AgentBnBError
+};