agentbnb 5.1.11 → 7.0.0-beta.1

package/dist/{service-coordinator-EYRDTHL5.js → service-coordinator-XBNT3SMU.js}

@@ -1,6 +1,13 @@
+import {
+  executeCapabilityBatch,
+  executeCapabilityRequest
+} from "./chunk-PGDBUUGR.js";
 import {
   StructuredFeedbackSchema
 } from "./chunk-AUBHR7HH.js";
+import {
+  RelayMessageSchema
+} from "./chunk-EHSHB7TY.js";
 import {
   KNOWN_API_KEYS,
   announceGateway,
@@ -8,17 +15,19 @@ import {
   detectApiKeys,
   getPricingStats,
   stopAnnouncement
-} from "./chunk-MLS6IGGG.js";
+} from "./chunk-FK2MDNTB.js";
 import {
   deriveAgentId
-} from "./chunk-QITOPASZ.js";
+} from "./chunk-PSQHUZ7X.js";
+import "./chunk-DUW6RX6I.js";
 import {
   createLedger,
   identityAuthPlugin
-} from "./chunk-FLY3WIQR.js";
+} from "./chunk-2HSUPCBT.js";
 import {
-  RelayMessageSchema
-} from "./chunk-QT7TEVNV.js";
+  ApiSkillConfigSchema,
+  parseSkillsFile
+} from "./chunk-OCSU2S6W.js";
 import {
   interpolateObject
 } from "./chunk-3MJT4PZG.js";
@@ -28,58 +37,55 @@ import {
   insertAuditEvent,
   listPendingRequests,
   resolvePendingRequest
-} from "./chunk-CSATDXZC.js";
+} from "./chunk-Y7T6IMM3.js";
 import {
   buildReputationMap,
   computeReputation,
   filterCards,
   searchCards
-} from "./chunk-NH2FIERR.js";
+} from "./chunk-574W3HHE.js";
+import {
+  bootstrapAgent,
+  getBalance,
+  getTransactions,
+  holdEscrow,
+  migrateOwner,
+  openCreditDb,
+  releaseEscrow,
+  settleEscrow
+} from "./chunk-J2K5S5MX.js";
+import "./chunk-NWIQJ2CL.js";
+import {
+  generateKeyPair,
+  verifyEscrowReceipt
+} from "./chunk-F53QQIM2.js";
 import {
   getConfigDir
 } from "./chunk-75OC6E4F.js";
-import {
-  executeCapabilityBatch,
-  executeCapabilityRequest
-} from "./chunk-QQFBFV4V.js";
-import "./chunk-UKT6H7YT.js";
 import {
   getActivityFeed,
   getCard,
+  getCardsBySkillCapability,
   getEvolutionHistory,
+  getFeedbackForProvider,
+  getFeedbackForSkill,
   getLatestEvolution,
   getRequestLog,
   getSkillRequestCount,
   insertCard,
   insertEvolution,
+  insertFeedback,
   insertRequestLog,
   listCards,
   openDatabase,
   updateCard,
   updateSkillAvailability,
   updateSkillIdleRate
-} from "./chunk-DFBX3BBD.js";
-import {
-  bootstrapAgent,
-  getBalance,
-  getFeedbackForProvider,
-  getFeedbackForSkill,
-  getTransactions,
-  holdEscrow,
-  insertFeedback,
-  migrateOwner,
-  openCreditDb,
-  releaseEscrow,
-  settleEscrow
-} from "./chunk-EANI2N2V.js";
-import {
-  generateKeyPair,
-  verifyEscrowReceipt
-} from "./chunk-5KFI5X7B.js";
+} from "./chunk-KA2VIEGM.js";
 import {
   AgentBnBError,
   AnyCardSchema
-} from "./chunk-WGZ5AGOX.js";
+} from "./chunk-3CIMVISQ.js";
 
 // src/runtime/agent-runtime.ts
 import { readFileSync, existsSync } from "fs";
@@ -88,13 +94,16 @@ import { readFileSync, existsSync } from "fs";
 var SkillExecutor = class {
   skillMap;
   modeMap;
+  concurrencyGuard;
   /**
    * @param configs - Parsed SkillConfig array (from parseSkillsFile).
    * @param modes - Map from skill type string to its executor implementation.
+   * @param concurrencyGuard - Optional ConcurrencyGuard to enforce max_concurrent limits.
    */
-  constructor(configs, modes) {
+  constructor(configs, modes, concurrencyGuard) {
     this.skillMap = new Map(configs.map((c) => [c.id, c]));
     this.modeMap = modes;
+    this.concurrencyGuard = concurrencyGuard;
   }
   /**
    * Execute a skill by ID with the given input parameters.
@@ -127,6 +136,18 @@ var SkillExecutor = class {
         latency_ms: Date.now() - startTime
       };
     }
+    const maxConcurrent = config.capacity?.max_concurrent ?? Infinity;
+    if (this.concurrencyGuard && maxConcurrent !== Infinity) {
+      if (!this.concurrencyGuard.canAccept(skillId, maxConcurrent)) {
+        return {
+          success: false,
+          error: `Skill ${skillId} at capacity (${maxConcurrent} concurrent max)`,
+          latency_ms: Date.now() - startTime,
+          failure_reason: "overload"
+        };
+      }
+      this.concurrencyGuard.acquire(skillId);
+    }
     try {
       const modeResult = await mode.execute(config, params, onProgress);
       return {
@@ -140,6 +161,10 @@ var SkillExecutor = class {
         error: message,
         latency_ms: Date.now() - startTime
       };
+    } finally {
+      if (this.concurrencyGuard && maxConcurrent !== Infinity) {
+        this.concurrencyGuard.release(skillId);
+      }
     }
   }
   /**
@@ -160,137 +185,8 @@ var SkillExecutor = class {
     return this.skillMap.get(skillId);
   }
 };
-function createSkillExecutor(configs, modes) {
-  return new SkillExecutor(configs, modes);
-}
-
-// src/skills/skill-config.ts
-import { z } from "zod";
-import yaml from "js-yaml";
-var PricingSchema = z.object({
-  credits_per_call: z.number().nonnegative(),
-  credits_per_minute: z.number().nonnegative().optional(),
-  free_tier: z.number().nonnegative().optional()
-});
-var ApiAuthSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("bearer"),
-    token: z.string()
-  }),
-  z.object({
-    type: z.literal("apikey"),
-    header: z.string().default("X-API-Key"),
-    key: z.string()
-  }),
-  z.object({
-    type: z.literal("basic"),
-    username: z.string(),
-    password: z.string()
-  })
-]);
-var ApiSkillConfigSchema = z.object({
-  id: z.string().min(1),
-  type: z.literal("api"),
-  name: z.string().min(1),
-  endpoint: z.string().min(1),
-  method: z.enum(["GET", "POST", "PUT", "DELETE"]),
-  auth: ApiAuthSchema.optional(),
-  input_mapping: z.record(z.string()).default({}),
-  output_mapping: z.record(z.string()).default({}),
-  pricing: PricingSchema,
-  timeout_ms: z.number().positive().default(3e4),
-  retries: z.number().nonnegative().int().default(0),
-  provider: z.string().optional()
-});
-var PipelineStepSchema = z.union([
-  z.object({
-    skill_id: z.string().min(1),
-    input_mapping: z.record(z.string()).default({})
-  }),
-  z.object({
-    command: z.string().min(1),
-    input_mapping: z.record(z.string()).default({})
-  })
-]);
-var PipelineSkillConfigSchema = z.object({
-  id: z.string().min(1),
-  type: z.literal("pipeline"),
-  name: z.string().min(1),
-  steps: z.array(PipelineStepSchema).min(1),
-  pricing: PricingSchema,
-  timeout_ms: z.number().positive().optional()
-});
-var OpenClawSkillConfigSchema = z.object({
-  id: z.string().min(1),
-  type: z.literal("openclaw"),
-  name: z.string().min(1),
-  agent_name: z.string().min(1),
-  channel: z.enum(["telegram", "webhook", "process"]),
-  pricing: PricingSchema,
-  timeout_ms: z.number().positive().optional()
-});
-var CommandSkillConfigSchema = z.object({
-  id: z.string().min(1),
-  type: z.literal("command"),
-  name: z.string().min(1),
-  command: z.string().min(1),
-  output_type: z.enum(["json", "text", "file"]),
-  allowed_commands: z.array(z.string()).optional(),
-  working_dir: z.string().optional(),
-  timeout_ms: z.number().positive().default(3e4),
-  pricing: PricingSchema
-});
-var ConductorSkillConfigSchema = z.object({
-  id: z.string().min(1),
-  type: z.literal("conductor"),
-  name: z.string().min(1),
-  conductor_skill: z.enum(["orchestrate", "plan"]),
-  pricing: PricingSchema,
-  timeout_ms: z.number().positive().optional()
-});
-var SkillConfigSchema = z.discriminatedUnion("type", [
-  ApiSkillConfigSchema,
-  PipelineSkillConfigSchema,
-  OpenClawSkillConfigSchema,
-  CommandSkillConfigSchema,
-  ConductorSkillConfigSchema
-]);
-var SkillsFileSchema = z.object({
-  skills: z.array(SkillConfigSchema)
-});
-function expandEnvVars(value) {
-  return value.replace(/\$\{([^}]+)\}/g, (_match, varName) => {
-    if (/[.a-z]/.test(varName)) {
-      return _match;
-    }
-    const envValue = process.env[varName];
-    if (envValue === void 0) {
-      throw new Error(`Environment variable "${varName}" is not defined`);
-    }
-    return envValue;
-  });
-}
-function expandEnvVarsDeep(value) {
-  if (typeof value === "string") {
-    return expandEnvVars(value);
-  }
-  if (Array.isArray(value)) {
-    return value.map(expandEnvVarsDeep);
-  }
-  if (value !== null && typeof value === "object") {
-    const result = {};
-    for (const [k, v] of Object.entries(value)) {
-      result[k] = expandEnvVarsDeep(v);
-    }
-    return result;
-  }
-  return value;
-}
-function parseSkillsFile(yamlContent) {
-  const raw = yaml.load(yamlContent);
-  const expanded = expandEnvVarsDeep(raw);
-  const result = SkillsFileSchema.parse(expanded);
-  return result.skills;
+function createSkillExecutor(configs, modes, concurrencyGuard) {
+  return new SkillExecutor(configs, modes, concurrencyGuard);
 }
 
 // src/skills/api-executor.ts
@@ -766,14 +662,32 @@ var CommandExecutor = class {
     const cmdConfig = config;
     const baseCommand = cmdConfig.command.trim().split(/\s+/)[0] ?? "";
     if (cmdConfig.allowed_commands && cmdConfig.allowed_commands.length > 0) {
-      if (!cmdConfig.allowed_commands.includes(baseCommand)) {
+      const effectiveAllowed = cmdConfig.claude_code ? [.../* @__PURE__ */ new Set([...cmdConfig.allowed_commands, "claude"])] : cmdConfig.allowed_commands;
+      const commandToCheck = cmdConfig.claude_code ? "claude" : baseCommand;
+      if (!effectiveAllowed.includes(commandToCheck)) {
         return {
           success: false,
-          error: `Command not allowed: "${baseCommand}". Allowed: ${cmdConfig.allowed_commands.join(", ")}`
+          error: `Command not allowed: "${commandToCheck}". Allowed: ${effectiveAllowed.join(", ")}`
         };
       }
     }
-    const interpolatedCommand = safeInterpolateCommand2(cmdConfig.command, { params });
+    let interpolatedCommand;
+    if (cmdConfig.claude_code) {
+      const parts = ["claude", "--print"];
+      if (cmdConfig.claude_code.auto_mode) {
+        parts.push("--dangerously-skip-permissions");
+      }
+      if (cmdConfig.claude_code.model) {
+        parts.push("--model", cmdConfig.claude_code.model);
+      }
+      if (cmdConfig.claude_code.system_prompt) {
+        parts.push("-p", shellEscape2(cmdConfig.claude_code.system_prompt));
+      }
+      const interpolatedPrompt = safeInterpolateCommand2(cmdConfig.command, { params });
+      interpolatedCommand = parts.join(" ") + " " + interpolatedPrompt;
+    } else {
+      interpolatedCommand = safeInterpolateCommand2(cmdConfig.command, { params });
+    }
     const timeout = cmdConfig.timeout_ms ?? 3e4;
     const cwd = cmdConfig.working_dir ?? process.cwd();
     let stdout;
@@ -914,8 +828,8 @@ var AgentRuntime = class {
     }
     const modes = /* @__PURE__ */ new Map();
     if (this.conductorEnabled) {
-      const { ConductorMode } = await import("./conductor-mode-Q4IIDY5E.js");
-      const { registerConductorCard, CONDUCTOR_OWNER } = await import("./card-RSGDCHCV.js");
+      const { ConductorMode } = await import("./conductor-mode-VGUU54QI.js");
+      const { registerConductorCard, CONDUCTOR_OWNER } = await import("./card-REW7BSWW.js");
       const { loadPeers } = await import("./peers-K7FSHPN3.js");
       registerConductorCard(this.registryDb);
       const resolveAgentUrl = (owner) => {
@@ -1021,6 +935,7 @@ var AgentRuntime = class {
 
 // src/gateway/server.ts
 import Fastify from "fastify";
+import { randomUUID } from "crypto";
 var VERSION = "0.0.1";
 function createGatewayServer(opts) {
   const {
@@ -1034,6 +949,8 @@ function createGatewayServer(opts) {
   } = opts;
   const fastify = Fastify({ logger: !silent });
   const tokenSet = new Set(tokens);
+  const inFlight = /* @__PURE__ */ new Map();
+  const OVERLOAD_RETRY_MS = 5e3;
   fastify.addHook("onRequest", async (request) => {
     if (request.method === "GET" && request.url === "/health") return;
     const auth = request.headers.authorization;
@@ -1099,18 +1016,63 @@ function createGatewayServer(opts) {
     }
     const requester = params.requester ?? "unknown";
     const receipt = params.escrow_receipt;
-    const result = await executeCapabilityRequest({
-      registryDb,
-      creditDb,
-      cardId,
-      skillId,
-      params,
-      requester,
-      escrowReceipt: receipt,
-      skillExecutor,
-      handlerUrl,
-      timeoutMs
-    });
+    if (skillExecutor && skillId && typeof skillExecutor.getSkillConfig === "function") {
+      const skillConfig = skillExecutor.getSkillConfig(skillId);
+      const maxConcurrent = skillConfig?.capacity?.max_concurrent;
+      if (maxConcurrent !== void 0) {
+        const current = inFlight.get(skillId) ?? 0;
+        if (current >= maxConcurrent) {
+          try {
+            insertRequestLog(registryDb, {
+              id: randomUUID(),
+              card_id: cardId,
+              card_name: "<overload>",
+              requester,
+              status: "failure",
+              latency_ms: 0,
+              credits_charged: 0,
+              created_at: (/* @__PURE__ */ new Date()).toISOString(),
+              skill_id: skillId,
+              failure_reason: "overload"
+            });
+          } catch {
+          }
+          return reply.status(200).send({
+            jsonrpc: "2.0",
+            id,
+            error: {
+              code: -32e3,
+              message: "overload",
+              data: { error: "overload", retry_after_ms: OVERLOAD_RETRY_MS }
+            }
+          });
+        }
+      }
+    }
+    const trackKey = skillId ?? cardId;
+    inFlight.set(trackKey, (inFlight.get(trackKey) ?? 0) + 1);
+    let result;
+    try {
+      result = await executeCapabilityRequest({
+        registryDb,
+        creditDb,
+        cardId,
+        skillId,
+        params,
+        requester,
+        escrowReceipt: receipt,
+        skillExecutor,
+        handlerUrl,
+        timeoutMs
+      });
+    } finally {
+      const next = (inFlight.get(trackKey) ?? 1) - 1;
+      if (next <= 0) {
+        inFlight.delete(trackKey);
+      } else {
+        inFlight.set(trackKey, next);
+      }
+    }
     if (result.success) {
       return reply.send({ jsonrpc: "2.0", id, result: result.result });
     } else {
@@ -1130,10 +1092,10 @@ import fastifyWebsocket from "@fastify/websocket";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { existsSync as existsSync2 } from "fs";
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 
 // src/relay/websocket-relay.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 
 // src/relay/relay-credit.ts
 function lookupCardPrice(registryDb, cardId, skillId) {
@@ -1191,10 +1153,10 @@ function releaseForRelay(creditDb, escrowId) {
 }
 
 // src/hub-agent/relay-bridge.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 
 // src/hub-agent/job-queue.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 function initJobQueue(db) {
   db.exec(`
     CREATE TABLE IF NOT EXISTS hub_agent_jobs (
@@ -1213,7 +1175,7 @@ function initJobQueue(db) {
   `);
 }
 function insertJob(db, input) {
-  const id = randomUUID();
+  const id = randomUUID2();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const paramsJson = JSON.stringify(input.params);
   db.prepare(`
@@ -1425,7 +1387,7 @@ function createRelayBridge(opts) {
       updateJobStatus(registryDb, job.id, "dispatched");
       const agent = getHubAgent(registryDb, job.hub_agent_id);
       const cardId = agent ? agent.agent_id.padEnd(32, "0").replace(/^(.{8})(.{4})(.{4})(.{4})(.{12}).*$/, "$1-$2-$3-$4-$5") : job.hub_agent_id;
-      const requestId = randomUUID2();
+      const requestId = randomUUID3();
       let params = {};
       try {
         params = JSON.parse(job.params);
@@ -1495,6 +1457,7 @@ function registerWebSocketRelay(server, db, creditDb) {
   const connections = /* @__PURE__ */ new Map();
   const pendingRequests = /* @__PURE__ */ new Map();
   const rateLimits = /* @__PURE__ */ new Map();
+  const agentCapacities = /* @__PURE__ */ new Map();
   let onAgentOnlineCallback;
   function checkRateLimit(owner) {
     const now = Date.now();
@@ -1571,7 +1534,7 @@ function registerWebSocketRelay(server, db, creditDb) {
   function logAgentJoined(owner, cardName, cardId) {
     try {
       insertRequestLog(db, {
-        id: randomUUID3(),
+        id: randomUUID4(),
         card_id: cardId,
         card_name: cardName,
         requester: owner,
@@ -1798,6 +1761,7 @@ function registerWebSocketRelay(server, db, creditDb) {
     if (!owner) return;
     connections.delete(owner);
     rateLimits.delete(owner);
+    agentCapacities.delete(owner);
     markOwnerOffline(owner);
     for (const [reqId, pending] of pendingRequests) {
       if (pending.targetOwner === owner) {
@@ -1831,6 +1795,9 @@ function registerWebSocketRelay(server, db, creditDb) {
       }
     }
   }
+  function handleHeartbeat(msg) {
+    agentCapacities.set(msg.owner, msg.capacity);
+  }
   void server.register(async (app) => {
     app.get("/ws", { websocket: true }, (rawSocket, _request) => {
       const socket = rawSocket;
@@ -1876,15 +1843,23 @@ function registerWebSocketRelay(server, db, creditDb) {
             case "relay_progress":
               handleRelayProgress(msg);
               break;
+            case "heartbeat":
+              handleHeartbeat(msg);
+              break;
             default:
               break;
           }
         })();
       });
+      const pingInterval = setInterval(() => {
+        if (socket.readyState === 1) socket.ping();
+      }, 3e4);
       socket.on("close", () => {
+        clearInterval(pingInterval);
         handleDisconnect(registeredOwner);
       });
       socket.on("error", () => {
+        clearInterval(pingInterval);
         handleDisconnect(registeredOwner);
       });
     });
@@ -1905,6 +1880,7 @@ function registerWebSocketRelay(server, db, creditDb) {
       }
       pendingRequests.clear();
       rateLimits.clear();
+      agentCapacities.clear();
     },
     setOnAgentOnline: (cb) => {
       onAgentOnlineCallback = cb;
@@ -1913,21 +1889,23 @@ function registerWebSocketRelay(server, db, creditDb) {
     getPendingRequests: () => pendingRequests,
     sendMessage: (ws, msg) => {
       sendMessage(ws, msg);
-    }
+    },
+    getAgentCapacity: (owner) => agentCapacities.get(owner),
+    getAllCapacities: () => new Map(agentCapacities)
   };
 }
 
 // src/identity/guarantor.ts
-import { z as z2 } from "zod";
-import { randomUUID as randomUUID4 } from "crypto";
+import { z } from "zod";
+import { randomUUID as randomUUID5 } from "crypto";
 var MAX_AGENTS_PER_GUARANTOR = 10;
 var GUARANTOR_CREDIT_POOL = 50;
-var GuarantorRecordSchema = z2.object({
-  id: z2.string().uuid(),
-  github_login: z2.string().min(1),
-  agent_count: z2.number().int().nonnegative(),
-  credit_pool: z2.number().int().nonnegative(),
-  created_at: z2.string().datetime()
+var GuarantorRecordSchema = z.object({
+  id: z.string().uuid(),
+  github_login: z.string().min(1),
+  agent_count: z.number().int().nonnegative(),
+  credit_pool: z.number().int().nonnegative(),
+  created_at: z.string().datetime()
 });
 var GUARANTOR_SCHEMA = `
   CREATE TABLE IF NOT EXISTS guarantors (
@@ -1958,7 +1936,7 @@ function registerGuarantor(db, githubLogin) {
     );
   }
   const record = {
-    id: randomUUID4(),
+    id: randomUUID5(),
     github_login: githubLogin,
     agent_count: 0,
     credit_pool: GUARANTOR_CREDIT_POOL,
@@ -2032,7 +2010,7 @@ function getAgentGuarantor(db, agentId) {
 function initiateGithubAuth() {
   return {
     auth_url: "https://github.com/login/oauth/authorize?client_id=PLACEHOLDER&scope=read:user",
-    state: randomUUID4()
+    state: randomUUID5()
   };
 }
 
@@ -2459,38 +2437,38 @@ var HubAgentExecutor = class {
 };
 
 // src/hub-agent/types.ts
-import { z as z3 } from "zod";
-var SkillRouteSchema = z3.discriminatedUnion("mode", [
-  z3.object({
-    skill_id: z3.string().min(1),
-    mode: z3.literal("direct_api"),
+import { z as z2 } from "zod";
+var SkillRouteSchema = z2.discriminatedUnion("mode", [
+  z2.object({
+    skill_id: z2.string().min(1),
+    mode: z2.literal("direct_api"),
     config: ApiSkillConfigSchema
   }),
-  z3.object({
-    skill_id: z3.string().min(1),
-    mode: z3.literal("relay"),
-    config: z3.object({ relay_owner: z3.string().min(1) })
+  z2.object({
+    skill_id: z2.string().min(1),
+    mode: z2.literal("relay"),
+    config: z2.object({ relay_owner: z2.string().min(1) })
   }),
-  z3.object({
-    skill_id: z3.string().min(1),
-    mode: z3.literal("queue"),
-    config: z3.object({ relay_owner: z3.string().min(1) }).passthrough()
+  z2.object({
+    skill_id: z2.string().min(1),
+    mode: z2.literal("queue"),
+    config: z2.object({ relay_owner: z2.string().min(1) }).passthrough()
   })
 ]);
-var HubAgentSchema = z3.object({
-  agent_id: z3.string().min(1),
-  name: z3.string().min(1),
-  owner_public_key: z3.string().min(1),
-  public_key: z3.string().min(1),
-  skill_routes: z3.array(SkillRouteSchema),
-  status: z3.enum(["active", "paused"]),
-  created_at: z3.string(),
-  updated_at: z3.string()
+var HubAgentSchema = z2.object({
+  agent_id: z2.string().min(1),
+  name: z2.string().min(1),
+  owner_public_key: z2.string().min(1),
+  public_key: z2.string().min(1),
+  skill_routes: z2.array(SkillRouteSchema),
+  status: z2.enum(["active", "paused"]),
+  created_at: z2.string(),
+  updated_at: z2.string()
 });
-var CreateAgentRequestSchema = z3.object({
-  name: z3.string().min(1),
-  skill_routes: z3.array(SkillRouteSchema),
-  secrets: z3.record(z3.string()).optional()
+var CreateAgentRequestSchema = z2.object({
+  name: z2.string().min(1),
+  skill_routes: z2.array(SkillRouteSchema),
+  secrets: z2.record(z2.string()).optional()
 });
 
 // src/hub-agent/routes.ts
@@ -3037,28 +3015,28 @@ var feedbackPlugin = async (fastify, opts) => {
 var api_default = feedbackPlugin;
 
 // src/evolution/schema.ts
-import { z as z4 } from "zod";
-var CoreMemoryEntrySchema = z4.object({
-  category: z4.string(),
-  importance: z4.number().min(0).max(1),
-  content: z4.string(),
-  scope: z4.string().optional()
+import { z as z3 } from "zod";
+var CoreMemoryEntrySchema = z3.object({
+  category: z3.string(),
+  importance: z3.number().min(0).max(1),
+  content: z3.string(),
+  scope: z3.string().optional()
 });
-var TemplateEvolutionSchema = z4.object({
+var TemplateEvolutionSchema = z3.object({
   /** e.g. "genesis-template" */
-  template_name: z4.string().min(1),
+  template_name: z3.string().min(1),
   /** Semantic version string, e.g. "1.2.3" */
-  template_version: z4.string().regex(/^\d+\.\d+\.\d+$/, "Must be a valid semver string (e.g. 1.2.3)"),
+  template_version: z3.string().regex(/^\d+\.\d+\.\d+$/, "Must be a valid semver string (e.g. 1.2.3)"),
   /** Identifier of the agent publishing this evolution */
-  publisher_agent: z4.string().min(1),
+  publisher_agent: z3.string().min(1),
   /** Human-readable description of what changed in this evolution */
-  changelog: z4.string().max(1e3),
+  changelog: z3.string().max(1e3),
   /** Snapshot of the agent's core memory at the time of evolution (max 50 entries) */
-  core_memory_snapshot: z4.array(CoreMemoryEntrySchema).max(50),
+  core_memory_snapshot: z3.array(CoreMemoryEntrySchema).max(50),
   /** Delta in fitness score from before evolution (range -1 to 1) */
-  fitness_improvement: z4.number().min(-1).max(1),
+  fitness_improvement: z3.number().min(-1).max(1),
   /** ISO 8601 datetime string */
-  timestamp: z4.string().datetime()
+  timestamp: z3.string().datetime()
 });
 
 // src/evolution/api.ts
@@ -3184,7 +3162,7 @@ function createRegistryServer(opts) {
       openapi: "3.0.3",
       info: {
         title: "AgentBnB Registry API",
-        description: "P2P Agent Capability Sharing Protocol \u2014 discover, publish, and exchange agent capabilities",
+        description: "Where AI agents hire AI agents \u2014 discover, publish, and coordinate agent capabilities",
         version: "3.1.6"
       },
       servers: [{ url: "/", description: "Registry server" }],
@@ -3216,7 +3194,7 @@ function createRegistryServer(opts) {
   });
   void server.register(cors, {
     origin: true,
-    methods: ["GET", "POST", "PATCH", "OPTIONS"],
+    methods: ["GET", "POST", "PATCH", "DELETE", "OPTIONS"],
     allowedHeaders: ["Content-Type", "Authorization", "X-Agent-PublicKey", "X-Agent-Signature", "X-Agent-Timestamp"]
   });
   void server.register(fastifyWebsocket);
@@ -3295,6 +3273,7 @@ function createRegistryServer(opts) {
             min_success_rate: { type: "number", description: "Minimum success rate (0-1)" },
             max_latency_ms: { type: "number", description: "Maximum average latency in ms" },
             min_reputation: { type: "number", description: "Minimum reputation score (0-1) based on peer feedback" },
+            capability_type: { type: "string", description: "Filter cards whose skills declare this capability_type (e.g. tts, code_gen)" },
             sort: { type: "string", enum: ["popular", "rated", "success_rate", "cheapest", "newest", "latency", "reputation_desc", "reputation_asc"], description: "Sort order" },
             limit: { type: "integer", default: 20, description: "Max items per page (max 100)" },
             offset: { type: "integer", default: 0, description: "Pagination offset" }
@@ -3321,6 +3300,7 @@ function createRegistryServer(opts) {
       const onlineRaw = query.online;
       const online = onlineRaw === "true" ? true : onlineRaw === "false" ? false : void 0;
       const tag = query.tag?.trim();
+      const capabilityType = query.capability_type?.trim() || void 0;
       const minSuccessRate = query.min_success_rate !== void 0 ? parseFloat(query.min_success_rate) : void 0;
       const maxLatencyMs = query.max_latency_ms !== void 0 ? parseFloat(query.max_latency_ms) : void 0;
       const minReputation = query.min_reputation !== void 0 ? parseFloat(query.min_reputation) : void 0;
@@ -3336,6 +3316,12 @@ function createRegistryServer(opts) {
         cards = filterCards(db, { level, online, min_reputation: minReputation });
       }
       cards = cards.filter((c) => !c.owner.includes(":req:"));
+      if (capabilityType !== void 0) {
+        const capTypeIds = new Set(
+          getCardsBySkillCapability(db, capabilityType).map((c) => c.id)
+        );
+        cards = cards.filter((c) => capTypeIds.has(c.id));
+      }
       if (tag !== void 0 && tag.length > 0) {
         cards = cards.filter((c) => {
           const rootTags = c.metadata?.tags ?? [];
@@ -3371,7 +3357,9 @@ function createRegistryServer(opts) {
         const trustStmt = db.prepare(`
         SELECT cc.owner,
           COUNT(rl.id) as total_exec,
-          SUM(CASE WHEN rl.status IN ('success','failure','timeout','refunded') THEN 1 ELSE 0 END) as terminal_exec,
+          SUM(CASE WHEN rl.status IN ('success','failure','timeout','refunded')
+              AND (rl.failure_reason IS NULL OR rl.failure_reason IN ('bad_execution','auth_error'))
+              THEN 1 ELSE 0 END) as terminal_exec,
           SUM(CASE WHEN rl.status = 'success' THEN 1 ELSE 0 END) as success_exec,
           AVG(CASE WHEN rl.status = 'success' THEN rl.latency_ms END) as avg_latency
         FROM capability_cards cc
@@ -3605,21 +3593,32 @@ function createRegistryServer(opts) {
     api.delete("/cards/:id", {
       schema: {
         tags: ["cards"],
-        summary: "Delete a capability card",
+        summary: "Delete a capability card (requires Bearer auth)",
+        security: [{ bearerAuth: [] }],
         params: { type: "object", properties: { id: { type: "string" } }, required: ["id"] },
         response: {
-          200: { type: "object", properties: { ok: { type: "boolean" }, id: { type: "string" } } },
+          204: { type: "null", description: "Card deleted successfully" },
+          401: { type: "object", properties: { error: { type: "string" } } },
+          403: { type: "object", properties: { error: { type: "string" } } },
           404: { type: "object", properties: { error: { type: "string" } } }
         }
       }
     }, async (request, reply) => {
+      const auth = request.headers.authorization;
+      const token = auth?.startsWith("Bearer ") ? auth.slice(7).trim() : null;
+      if (!token || !opts.ownerApiKey || token !== opts.ownerApiKey) {
+        return reply.code(401).send({ error: "Unauthorized" });
+      }
       const { id } = request.params;
       const card = getCard(db, id);
       if (!card) {
         return reply.code(404).send({ error: "Not found" });
       }
+      if (opts.ownerName && card.owner !== opts.ownerName) {
+        return reply.code(403).send({ error: "Forbidden" });
+      }
       db.prepare("DELETE FROM capability_cards WHERE id = ?").run(id);
-      return reply.send({ ok: true, id });
+      return reply.code(204).send();
     });
     api.get("/api/agents", {
       schema: {
@@ -3704,7 +3703,8 @@ function createRegistryServer(opts) {
       const lastActive = lastActiveRow?.last_req ?? memberRow?.latest ?? joinedAt;
       const metricsStmt = db.prepare(`
       SELECT
-        COUNT(*) as total,
+        SUM(CASE WHEN rl.failure_reason IS NULL OR rl.failure_reason IN ('bad_execution','auth_error')
+            THEN 1 ELSE 0 END) as total,
         SUM(CASE WHEN rl.status = 'success' THEN 1 ELSE 0 END) as successes,
         AVG(CASE WHEN rl.status = 'success' THEN rl.latency_ms END) as avg_latency,
         COUNT(DISTINCT rl.requester) as unique_requesters,
@@ -4032,16 +4032,16 @@ function createRegistryServer(opts) {
       const gptActions = convertToGptActions(openapiSpec, serverUrl);
       return reply.send(gptActions);
     });
-    const BatchRequestBodySchema = z5.object({
-      requests: z5.array(
-        z5.object({
-          skill_id: z5.string().min(1),
-          params: z5.record(z5.unknown()).default({}),
-          max_credits: z5.number().positive()
+    const BatchRequestBodySchema = z4.object({
+      requests: z4.array(
+        z4.object({
+          skill_id: z4.string().min(1),
+          params: z4.record(z4.unknown()).default({}),
+          max_credits: z4.number().positive()
         })
       ).min(1),
-      strategy: z5.enum(["parallel", "sequential", "best_effort"]),
-      total_budget: z5.number().positive()
+      strategy: z4.enum(["parallel", "sequential", "best_effort"]),
+      total_budget: z4.number().positive()
     });
     api.post("/api/request/batch", {
       schema: {
@@ -4297,6 +4297,110 @@ function createRegistryServer(opts) {
         });
       });
     }
+    api.get("/api/providers/:owner/reliability", {
+      schema: {
+        tags: ["agents"],
+        summary: "Get provider reliability metrics",
+        params: { type: "object", properties: { owner: { type: "string" } }, required: ["owner"] },
+        response: {
+          200: {
+            type: "object",
+            properties: {
+              current_streak: { type: "integer" },
+              longest_streak: { type: "integer" },
+              total_hires: { type: "integer" },
+              repeat_hires: { type: "integer" },
+              repeat_hire_rate: { type: "number" },
+              avg_feedback_score: { type: "number" },
+              availability_rate: { type: "number" }
+            }
+          },
+          404: { type: "object", properties: { error: { type: "string" } } }
+        }
+      }
+    }, async (request, reply) => {
+      const { owner } = request.params;
+      if (!opts.creditDb) {
+        return reply.code(404).send({ error: "Credit system not enabled" });
+      }
+      const { getReliabilityMetrics } = await import("./reliability-metrics-QG7WC5QK.js");
+      const metrics = getReliabilityMetrics(opts.creditDb, owner);
+      if (!metrics) {
+        return reply.code(404).send({ error: "No reliability data for this provider" });
+      }
+      return reply.send(metrics);
+    });
+    api.get("/api/fleet/:owner", {
+      schema: {
+        tags: ["agents"],
+        summary: "Agent fleet overview for an owner",
+        params: { type: "object", properties: { owner: { type: "string" } }, required: ["owner"] },
+        response: {
+          200: { type: "object", properties: { agents: { type: "array" } } }
+        }
+      }
+    }, async (request, reply) => {
+      const { owner } = request.params;
+      const rows = db.prepare(
+        "SELECT id, data FROM capability_cards WHERE owner = ?"
+      ).all(owner);
+      const agents = [];
+      for (const row of rows) {
+        try {
+          const card = JSON.parse(row.data);
+          let earnings = 0;
+          let spend = 0;
+          if (opts.creditDb) {
+            const earningRow = opts.creditDb.prepare(
+              "SELECT COALESCE(SUM(amount), 0) as total FROM credit_transactions WHERE owner = ? AND reason = 'settlement' AND amount > 0"
+            ).get(owner);
+            earnings = earningRow.total;
+            const spendRow = opts.creditDb.prepare(
+              "SELECT COALESCE(SUM(ABS(amount)), 0) as total FROM credit_transactions WHERE owner = ? AND reason = 'escrow_hold'"
+            ).get(owner);
+            spend = spendRow.total;
+          }
+          const successCount = db.prepare(
+            "SELECT COUNT(*) as cnt FROM request_log WHERE card_id = ? AND status = 'success' AND (action_type IS NULL OR action_type = 'auto_share')"
+          ).get(row.id).cnt;
+          const failureCount = db.prepare(
+            "SELECT COUNT(*) as cnt FROM request_log WHERE card_id = ? AND status IN ('failure', 'timeout', 'refunded') AND (action_type IS NULL OR action_type = 'auto_share')"
+          ).get(row.id).cnt;
+          const totalExec = successCount + failureCount;
+          const successRate = totalExec > 0 ? successCount / totalExec : 0;
+          let failureBreakdown = {};
+          try {
+            const failureRows = db.prepare(
+              "SELECT failure_reason, COUNT(*) as cnt FROM request_log WHERE card_id = ? AND status IN ('failure', 'timeout', 'refunded') AND failure_reason IS NOT NULL GROUP BY failure_reason"
+            ).all(row.id);
+            for (const fr of failureRows) {
+              failureBreakdown[fr.failure_reason] = fr.cnt;
+            }
+          } catch {
+          }
+          let reliability = null;
+          if (opts.creditDb) {
+            const { getReliabilityMetrics } = await import("./reliability-metrics-QG7WC5QK.js");
+            reliability = getReliabilityMetrics(opts.creditDb, owner);
+          }
+          agents.push({
+            id: row.id,
+            name: card.name ?? card.agent_name ?? owner,
+            online: card.availability?.online ?? false,
+            current_load: 0,
+            // Will be populated from relay heartbeat data in future
+            success_rate: successRate,
+            total_executions: totalExec,
+            earnings,
+            spend,
+            failure_breakdown: failureBreakdown,
+            reliability
+          });
+        } catch {
+        }
+      }
+      return reply.send({ agents });
+    });
   });
   return { server, relayState };
 }
@@ -4400,7 +4504,7 @@ import { createRequire } from "module";
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname as dirname2, join as join2, resolve } from "path";
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 var ServiceCoordinator = class {
   config;
   guard;
@@ -4541,7 +4645,7 @@ var ServiceCoordinator = class {
       console.log("Conductor mode enabled \u2014 orchestrate/plan skills available via gateway");
     }
     if (opts.conductorEnabled && this.config.conductor?.public) {
-      const { buildConductorCard } = await import("./card-RSGDCHCV.js");
+      const { buildConductorCard } = await import("./card-REW7BSWW.js");
       const conductorCard = buildConductorCard(this.config.owner);
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const existing = this.runtime.registryDb.prepare("SELECT id FROM capability_cards WHERE id = ?").get(conductorCard.id);
@@ -4598,11 +4702,11 @@ var ServiceCoordinator = class {
       }
     }
     if (opts.registryUrl && opts.relay) {
-      const { RelayClient } = await import("./websocket-client-6IIDGXKB.js");
-      const { executeCapabilityRequest: executeCapabilityRequest2 } = await import("./execute-T7Y6RKSW.js");
+      const { RelayClient } = await import("./websocket-client-5MH6QRJK.js");
+      const { executeCapabilityRequest: executeCapabilityRequest2 } = await import("./execute-MOXSSA3Q.js");
       const cards = listCards(this.runtime.registryDb, this.config.owner);
       const card = cards[0] ?? {
-        id: randomUUID5(),
+        id: randomUUID6(),
         owner: this.config.owner,
         name: this.config.owner,
         description: "Agent registered via CLI",
@@ -4615,7 +4719,7 @@ var ServiceCoordinator = class {
       };
       const additionalCards = [];
       if (this.config.conductor?.public) {
-        const { buildConductorCard } = await import("./card-RSGDCHCV.js");
+        const { buildConductorCard } = await import("./card-REW7BSWW.js");
         additionalCards.push(
           buildConductorCard(this.config.owner)
         );
@@ -4865,7 +4969,6 @@ var ServiceCoordinator = class {
     })();
   };
 };
-var require2 = createRequire(import.meta.url);
 function loadPersistedRuntime(configDir) {
   const runtimePath = join2(configDir, "runtime.json");
   if (!existsSync3(runtimePath)) return null;
@@ -4893,6 +4996,12 @@ function resolveNodeExecutable(runtime) {
   return process.execPath;
 }
 function resolveCliLaunchArgs(serveArgs) {
+  const require2 = createRequire(import.meta.url);
+  try {
+    const distCli2 = require2.resolve("agentbnb/dist/cli/index.js");
+    return [distCli2, "serve", ...serveArgs];
+  } catch {
+  }
   const projectRoot = resolve(dirname2(fileURLToPath2(import.meta.url)), "..", "..");
   const distCli = join2(projectRoot, "dist", "cli", "index.js");
   if (existsSync3(distCli)) {