agentbnb 7.0.0 → 8.2.0

package/dist/skills/agentbnb/bootstrap.js

@@ -1,18 +1,30 @@
 import {
+  AutoRequestor,
+  BudgetController,
+  BudgetManager,
   DEFAULT_AUTONOMY_CONFIG,
+  DEFAULT_BUDGET_CONFIG,
+  ORCHESTRATION_FEE,
   buildReputationMap,
   computeReputation,
+  decompose,
   fetchRemoteCards,
   filterCards,
   getAutonomyTier,
   insertAuditEvent,
   interpolateObject,
   listPendingRequests,
+  matchSubTasks,
+  mergeResults,
+  orchestrate,
   requestCapability,
   requestViaRelay,
   resolvePendingRequest,
   searchCards
-} from "../../chunk-B2VJTKO5.js";
+} from "../../chunk-P4LOYSLA.js";
+import {
+  loadPeers
+} from "../../chunk-HLUEOLSZ.js";
 import {
   executeCapabilityBatch,
   executeCapabilityRequest,
@@ -67,9 +79,10 @@ import {
 } from "../../chunk-3LWBH7P3.js";
 
 // skills/agentbnb/bootstrap.ts
-import { join as join5 } from "path";
-import { homedir as homedir2 } from "os";
-import { spawnSync } from "child_process";
+import { join as join6, basename, dirname as dirname4 } from "path";
+import { homedir as homedir3 } from "os";
+import { spawnSync, exec } from "child_process";
+import { promisify as promisify2 } from "util";
 import { randomUUID as randomUUID10 } from "crypto";
 
 // src/runtime/process-guard.ts
@@ -1258,12 +1271,12 @@ var AgentRuntime = class {
     }
     const modes = /* @__PURE__ */ new Map();
     if (this.conductorEnabled) {
-      const { ConductorMode } = await import("../../conductor-mode-2GSLHVN6.js");
+      const { ConductorMode } = await import("../../conductor-mode-TFCVCQHU.js");
       const { registerConductorCard, CONDUCTOR_OWNER } = await import("../../card-EX2EYGCZ.js");
-      const { loadPeers } = await import("../../peers-CJ7T4RJO.js");
+      const { loadPeers: loadPeers2 } = await import("../../peers-CJ7T4RJO.js");
       registerConductorCard(this.registryDb);
       const resolveAgentUrl = (owner) => {
-        const peers = loadPeers();
+        const peers = loadPeers2();
         const peer = peers.find((p) => p.name.toLowerCase() === owner.toLowerCase());
         if (!peer) {
           throw new Error(
@@ -6734,23 +6747,705 @@ function isNetworkError(err) {
   return msg.includes("NETWORK_ERROR") || msg.includes("ECONNREFUSED") || msg.includes("fetch failed") || msg.includes("Network error");
 }
 
+// skills/agentbnb/openclaw-tools.ts
+import { readFileSync as readFileSync5, existsSync as existsSync6 } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/mcp/tools/discover.ts
+import { z as z9 } from "zod";
+var discoverInputSchema = {
+  query: z9.string().describe("Natural language search query"),
+  level: z9.number().optional().describe("Filter by capability level (1=Atomic, 2=Pipeline, 3=Environment)"),
+  online_only: z9.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 }) }]
+    };
+  }
+}
+
+// src/mcp/tools/request.ts
+import { z as z10 } from "zod";
+var requestInputSchema = {
+  query: z10.string().optional().describe("Search query to find a matching capability (auto-request mode)"),
+  card_id: z10.string().optional().describe("Direct card ID to request (skips search)"),
+  skill_id: z10.string().optional().describe("Specific skill within a v2.0 card"),
+  params: z10.record(z10.unknown()).optional().describe("Input parameters for the capability"),
+  max_cost: z10.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 && localCard.owner === ctx.config.owner) {
+        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 } : {}, requester: ctx.config.owner }
+        });
+        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 } : {}, requester: ctx.config.owner }
+          });
+          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 }) }]
+    };
+  }
+}
+
+// src/mcp/tools/conduct.ts
+import { z as z11 } from "zod";
+
+// src/cli/conduct.ts
+async function conductAction(task, opts) {
+  const config = loadConfig();
+  if (!config) {
+    return { success: false, error: "Not initialized. Run `agentbnb init` first." };
+  }
+  const maxBudget = parseInt(opts.maxBudget ?? "100", 10);
+  const subtasks = decompose(task);
+  if (subtasks.length === 0) {
+    return { success: false, error: "No matching template for this task" };
+  }
+  const db = openDatabase(config.db_path);
+  let matchResults;
+  try {
+    matchResults = await matchSubTasks({
+      db,
+      subtasks,
+      conductorOwner: config.owner,
+      registryUrl: config.registry
+    });
+  } finally {
+    db.close();
+  }
+  const creditDb = openCreditDb(config.credit_db_path);
+  let budget;
+  try {
+    const budgetManager = new BudgetManager(creditDb, config.owner);
+    const budgetController = new BudgetController(budgetManager, maxBudget);
+    budget = budgetController.calculateBudget(matchResults);
+  } finally {
+    creditDb.close();
+  }
+  const plan = subtasks.map((st, i) => {
+    const match = matchResults.find((m) => m.subtask_id === st.id);
+    return {
+      step: i + 1,
+      description: st.description,
+      capability: st.required_capability,
+      agent: match?.selected_agent || "(unmatched)",
+      credits: match?.credits ?? st.estimated_credits,
+      depends_on: st.depends_on
+    };
+  });
+  const planOutput = {
+    steps: plan,
+    orchestration_fee: ORCHESTRATION_FEE,
+    estimated_total: budget.estimated_total,
+    max_budget: maxBudget
+  };
+  if (opts.planOnly) {
+    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) {
+      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 connect ${owner} <url> <token>`
+    );
+  };
+  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;
+  }
+  return {
+    success: orchResult.success,
+    plan: planOutput,
+    execution: resultObj,
+    total_credits: orchResult.total_credits,
+    latency_ms: orchResult.latency_ms,
+    errors: orchResult.errors
+  };
+}
+
+// src/mcp/tools/conduct.ts
+var conductInputSchema = {
+  task: z11.string().describe("Natural language task description"),
+  plan_only: z11.boolean().optional().default(false).describe("If true, return execution plan without executing"),
+  max_budget: z11.number().optional().default(100).describe("Maximum credits to spend")
+};
+async function handleConduct(args, _ctx) {
+  try {
+    const result = await conductAction(args.task, {
+      planOnly: args.plan_only ?? false,
+      maxBudget: String(args.max_budget ?? 100)
+    });
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error during conduct";
+    return {
+      content: [{ type: "text", text: JSON.stringify({ success: false, error: message }) }]
+    };
+  }
+}
+
+// src/mcp/tools/status.ts
+import { z as z12 } from "zod";
+var statusInputSchema = {
+  _unused: z12.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 }) }]
+    };
+  }
+}
+
+// src/mcp/tools/publish.ts
+import { z as z13 } from "zod";
+var publishInputSchema = {
+  card_json: z13.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 }) }]
+    };
+  }
+}
+
+// skills/agentbnb/openclaw-tools.ts
+var contextCache = /* @__PURE__ */ new Map();
+function resolveConfigDir(toolCtx) {
+  if (toolCtx.agentDir) {
+    return toolCtx.agentDir.endsWith(".agentbnb") ? toolCtx.agentDir : join5(toolCtx.agentDir, ".agentbnb");
+  }
+  if (toolCtx.workspaceDir) {
+    return join5(toolCtx.workspaceDir, ".agentbnb");
+  }
+  return join5(homedir2(), ".agentbnb");
+}
+function buildMcpContext(toolCtx) {
+  const configDir = resolveConfigDir(toolCtx);
+  const cached = contextCache.get(configDir);
+  if (cached) return cached;
+  const configPath = join5(configDir, "config.json");
+  if (!existsSync6(configPath)) {
+    throw new Error(
+      `AgentBnB not initialized at ${configDir}. Run \`agentbnb init\` or activate the plugin first.`
+    );
+  }
+  const config = JSON.parse(readFileSync5(configPath, "utf-8"));
+  const identity = ensureIdentity(configDir, config.owner);
+  const ctx = { configDir, config, identity };
+  contextCache.set(configDir, ctx);
+  return ctx;
+}
+function toAgentToolResult(mcpResult) {
+  const text = mcpResult.content[0]?.text ?? "{}";
+  let details;
+  try {
+    details = JSON.parse(text);
+  } catch {
+    details = void 0;
+  }
+  return { content: text, details };
+}
+function createDiscoverTool(toolCtx) {
+  return {
+    name: "agentbnb-discover",
+    label: "AgentBnB Discover",
+    description: "Search for agent capabilities on the AgentBnB network. Returns matching capability cards from both local and remote registries.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Natural language search query" },
+        level: {
+          type: "number",
+          description: "Filter by capability level (1=Atomic, 2=Pipeline, 3=Environment)"
+        },
+        online_only: { type: "boolean", description: "Only show online agents" }
+      },
+      required: ["query"]
+    },
+    async execute(_toolCallId, params) {
+      const ctx = buildMcpContext(toolCtx);
+      const result = await handleDiscover(
+        params,
+        ctx
+      );
+      return toAgentToolResult(result);
+    }
+  };
+}
+function createRequestTool(toolCtx) {
+  return {
+    name: "agentbnb-request",
+    label: "AgentBnB Request",
+    description: "Request execution of a skill from another agent on the AgentBnB network. Handles credit escrow automatically.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search query to find a matching capability (auto-request mode)"
+        },
+        card_id: { type: "string", description: "Direct card ID to request (skips search)" },
+        skill_id: { type: "string", description: "Specific skill within a v2.0 card" },
+        params: { type: "object", description: "Input parameters for the capability" },
+        max_cost: {
+          type: "number",
+          description: "Maximum credits to spend (default: 50)"
+        }
+      },
+      required: []
+    },
+    async execute(_toolCallId, params) {
+      const ctx = buildMcpContext(toolCtx);
+      const result = await handleRequest(
+        params,
+        ctx
+      );
+      return toAgentToolResult(result);
+    }
+  };
+}
+function createConductTool(toolCtx) {
+  return {
+    name: "agentbnb-conduct",
+    label: "AgentBnB Conduct",
+    description: "Orchestrate a complex task across multiple agents on the AgentBnB network. Decomposes the task, matches sub-tasks to agents, and executes the pipeline.",
+    parameters: {
+      type: "object",
+      properties: {
+        task: { type: "string", description: "Natural language task description" },
+        plan_only: {
+          type: "boolean",
+          description: "If true, return execution plan without executing"
+        },
+        max_budget: {
+          type: "number",
+          description: "Maximum credits to spend (default: 100)"
+        }
+      },
+      required: ["task"]
+    },
+    async execute(_toolCallId, params) {
+      const ctx = buildMcpContext(toolCtx);
+      const result = await handleConduct(
+        params,
+        ctx
+      );
+      return toAgentToolResult(result);
+    }
+  };
+}
+function createStatusTool(toolCtx) {
+  return {
+    name: "agentbnb-status",
+    label: "AgentBnB Status",
+    description: "Check your AgentBnB agent status: identity, credit balance, and configuration.",
+    parameters: {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    async execute(_toolCallId, _params) {
+      const ctx = buildMcpContext(toolCtx);
+      const result = await handleStatus(ctx);
+      return toAgentToolResult(result);
+    }
+  };
+}
+function createPublishTool(toolCtx) {
+  return {
+    name: "agentbnb-publish",
+    label: "AgentBnB Publish",
+    description: "Publish a capability card to the AgentBnB network. Stores locally and optionally syncs to remote registry.",
+    parameters: {
+      type: "object",
+      properties: {
+        card_json: {
+          type: "string",
+          description: "JSON string of the capability card to publish"
+        }
+      },
+      required: ["card_json"]
+    },
+    async execute(_toolCallId, params) {
+      const ctx = buildMcpContext(toolCtx);
+      const result = await handlePublish(params, ctx);
+      return toAgentToolResult(result);
+    }
+  };
+}
+function createAllTools(toolCtx) {
+  return [
+    createDiscoverTool(toolCtx),
+    createRequestTool(toolCtx),
+    createConductTool(toolCtx),
+    createStatusTool(toolCtx),
+    createPublishTool(toolCtx)
+  ];
+}
+
 // skills/agentbnb/bootstrap.ts
+var execAsync = promisify2(exec);
 function resolveWorkspaceDir() {
   if (process.env["AGENTBNB_DIR"]) {
     return process.env["AGENTBNB_DIR"];
   }
-  const openclawAgentsDir = join5(homedir2(), ".openclaw", "agents");
+  const openclawAgentsDir = join6(homedir3(), ".openclaw", "agents");
   const cwd = process.cwd();
   if (cwd.startsWith(openclawAgentsDir + "/")) {
     const relative = cwd.slice(openclawAgentsDir.length + 1);
     const agentName = relative.split("/")[0];
-    return join5(openclawAgentsDir, agentName, ".agentbnb");
+    return join6(openclawAgentsDir, agentName, ".agentbnb");
   }
-  return join5(homedir2(), ".agentbnb");
+  return join6(homedir3(), ".agentbnb");
 }
 function registerDecomposerCard(configDir, owner) {
   try {
-    const db = openDatabase(join5(configDir, "registry.db"));
+    const db = openDatabase(join6(configDir, "registry.db"));
     const existing = db.prepare(
       "SELECT id FROM capability_cards WHERE owner = ? AND json_extract(data, '$.capability_type') = ?"
     ).get(owner, "task_decomposition");
@@ -6807,7 +7502,58 @@ function registerDecomposerCard(configDir, owner) {
     );
   }
 }
-async function activate(config = {}) {
+function findCli() {
+  const result = spawnSync("which", ["agentbnb"], { encoding: "utf-8", stdio: "pipe" });
+  if (result.status === 0 && result.stdout.trim()) {
+    return result.stdout.trim();
+  }
+  return null;
+}
+async function runCommand(cmd, env) {
+  return execAsync(cmd, { env });
+}
+function deriveAgentName(configDir) {
+  const parent = basename(dirname4(configDir));
+  if (parent && parent !== "." && parent !== ".agentbnb" && parent !== homedir3().split("/").pop()) {
+    return parent;
+  }
+  return `agent-${randomUUID10().slice(0, 8)}`;
+}
+var defaultDeps = { findCli, runCommand };
+async function autoOnboard(configDir, deps = defaultDeps) {
+  process.stderr.write("[agentbnb] First-time setup: initializing agent identity...\n");
+  const cliPath = deps.findCli();
+  if (!cliPath) {
+    process.stderr.write("[agentbnb] CLI not found. Run: npm install -g agentbnb\n");
+    throw new AgentBnBError(
+      "agentbnb CLI not found in PATH. Install with: npm install -g agentbnb",
+      "INIT_FAILED"
+    );
+  }
+  const env = { ...process.env, AGENTBNB_DIR: configDir };
+  const agentName = deriveAgentName(configDir);
+  try {
+    await deps.runCommand(`agentbnb init --owner "${agentName}" --yes --no-detect`, env);
+    process.stderr.write(`[agentbnb] Agent "${agentName}" initialized.
+`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new AgentBnBError(`Auto-init failed: ${msg}`, "INIT_FAILED");
+  }
+  try {
+    await deps.runCommand("agentbnb openclaw sync", env);
+    process.stderr.write("[agentbnb] Capabilities published from SOUL.md.\n");
+  } catch {
+    process.stderr.write("[agentbnb] Note: openclaw sync skipped (SOUL.md may not exist yet).\n");
+  }
+  const config = loadConfig();
+  if (!config) {
+    throw new AgentBnBError("AgentBnB config still not found after auto-init", "CONFIG_NOT_FOUND");
+  }
+  process.stderr.write("[agentbnb] Agent initialized and published to AgentBnB network.\n");
+  return config;
+}
+async function activate(config = {}, _onboardDeps) {
   if (config.agentDir) {
     process.env["AGENTBNB_DIR"] = config.agentDir;
     process.stderr.write(
@@ -6815,7 +7561,7 @@ async function activate(config = {}) {
 `
     );
   } else if (config.workspaceDir) {
-    const derived = join5(config.workspaceDir, ".agentbnb");
+    const derived = join6(config.workspaceDir, ".agentbnb");
     process.env["AGENTBNB_DIR"] = derived;
     process.stderr.write(
       `[agentbnb] AGENTBNB_DIR derived from config.workspaceDir: ${derived}
@@ -6838,25 +7584,13 @@ async function activate(config = {}) {
   }
   let agentConfig = loadConfig();
   if (!agentConfig) {
-    const result = spawnSync("agentbnb", ["init", "--yes", "--no-detect"], {
-      stdio: "pipe",
-      env: { ...process.env },
-      encoding: "utf-8"
-    });
-    if (result.error || result.status !== 0) {
-      const msg = result.error?.message ?? result.stderr?.trim() ?? "agentbnb init failed";
-      throw new AgentBnBError(`Auto-init failed: ${msg}`, "INIT_FAILED");
-    }
-    agentConfig = loadConfig();
-    if (!agentConfig) {
-      throw new AgentBnBError("AgentBnB config still not found after auto-init", "CONFIG_NOT_FOUND");
-    }
+    agentConfig = await autoOnboard(configDir, _onboardDeps);
   }
   process.stderr.write(
     `[agentbnb] activate: owner=${agentConfig.owner} config=${configDir}/config.json
 `
   );
-  const guard = new ProcessGuard(join5(configDir, ".pid"));
+  const guard = new ProcessGuard(join6(configDir, ".pid"));
   const coordinator = new ServiceCoordinator(agentConfig, guard);
   const service = new AgentBnBService(coordinator, agentConfig);
   const opts = {
@@ -6894,7 +7628,20 @@ async function deactivate(ctx) {
     }
   }
 }
+var bootstrap_default = {
+  id: "agentbnb",
+  name: "AgentBnB",
+  description: "Where AI agents hire AI agents \u2014 discover, request, and orchestrate agent capabilities.",
+  register(api) {
+    api.registerTool(
+      (toolCtx) => createAllTools(toolCtx)
+    );
+  }
+};
 export {
   activate,
-  deactivate
+  deactivate,
+  bootstrap_default as default,
+  findCli,
+  runCommand
 };