agentbnb 7.0.0 → 8.2.0

package/dist/cli/index.js

@@ -84,7 +84,6 @@ import {
 // src/cli/index.ts
 import { Command } from "commander";
 import { readFileSync as readFileSync4 } from "fs";
-import { createRequire } from "module";
 import { randomUUID as randomUUID4 } from "crypto";
 import { join as join4 } from "path";
 import { networkInterfaces as networkInterfaces2 } from "os";
@@ -868,6 +867,18 @@ function registerMcpWithClaudeCode() {
     const resolved = execSync("which agentbnb", { encoding: "utf-8" }).trim();
     if (resolved) agentbnbCommand = resolved;
   } catch {
+    try {
+      const scriptPath = process.argv[1];
+      if (scriptPath && existsSync3(scriptPath)) {
+        agentbnbCommand = scriptPath;
+      }
+    } catch {
+    }
+  }
+  if (agentbnbCommand === "agentbnb") {
+    console.warn(
+      "Warning: Could not resolve absolute path to agentbnb binary.\n  Claude Code MCP may not work. Install globally first:\n  npm install -g agentbnb"
+    );
   }
   let settings = {};
   if (existsSync3(settingsPath)) {
@@ -995,8 +1006,7 @@ Skills: ${skills.skillCount} skill(s) in ${skills.path}`);
 }
 
 // src/cli/index.ts
-var require2 = createRequire(import.meta.url);
-var pkg = require2("../../package.json");
+var VERSION = "8.2.0";
 function loadIdentityAuth2(owner) {
   const configDir = getConfigDir();
   let keys;
@@ -1023,7 +1033,7 @@ function getLanIp2() {
   return "localhost";
 }
 var program = new Command();
-program.name("agentbnb").description("P2P Agent Capability Sharing Protocol \u2014 Airbnb for AI agent pipelines").version(pkg.version);
+program.name("agentbnb").description("P2P Agent Capability Sharing Protocol \u2014 Airbnb for AI agent pipelines").version(VERSION);
 program.command("init").description("Initialize AgentBnB config and create agent identity").option("--owner <name>", "Agent owner name").option("--agent-id <id>", "Agent identity (alias for --owner, for genesis-template compat)").option("--port <port>", "Gateway port", "7700").option("--host <ip>", "Override gateway host IP (default: auto-detected LAN IP)").option("--yes", "Auto-confirm all draft cards (non-interactive)").option("--non-interactive", "Non-interactive mode (alias for --yes)").option("--no-detect", "Skip API key detection").option("--from <file>", "Parse a specific file for capability detection").option("--json", "Output as JSON").action(async (opts) => {
   const result = await performInit(opts);
   if (opts.json) {
@@ -2327,7 +2337,7 @@ Feedback for skill: ${opts.skill} (${feedbacks.length} entries)
 });
 program.command("quickstart").alias("qs").description("One-command setup: init + skills.yaml + MCP registration + serve daemon").option("--owner <name>", "Agent owner name").option("--port <port>", "Gateway port", "7700").option("--no-serve", "Skip starting background daemon").option("--no-mcp", "Skip MCP registration with Claude Code").option("--json", "Output as JSON").action(runQuickstart);
 program.command("mcp-server").description("Start an MCP (Model Context Protocol) server for IDE integration").action(async () => {
-  const { startMcpServer } = await import("../server-MHMAYXWZ.js");
+  const { startMcpServer } = await import("../server-LMY2A3GT.js");
   await startMcpServer();
 });
 await program.parseAsync(process.argv);

package/dist/conductor-mode-TFCVCQHU.js

@@ -0,0 +1,266 @@
+import {
+  BudgetController,
+  BudgetManager,
+  decompose,
+  matchSubTasks,
+  orchestrate,
+  requestCapability,
+  validateAndNormalizeSubtasks
+} from "./chunk-P4LOYSLA.js";
+import "./chunk-HLUEOLSZ.js";
+import {
+  getCardsByCapabilityType,
+  getCardsBySkillCapability
+} from "./chunk-7EF3HYVZ.js";
+import "./chunk-NWIQJ2CL.js";
+import "./chunk-IVOYM3WG.js";
+import "./chunk-WVY2W7AA.js";
+
+// src/conductor/team-formation.ts
+import { randomUUID } from "crypto";
+function selectByStrategy(matches, strategy) {
+  if (matches.length === 0) return void 0;
+  if (strategy === "balanced") {
+    return matches[0];
+  }
+  if (strategy === "quality_optimized") {
+    return matches.reduce((best, m) => m.score > best.score ? m : best, matches[0]);
+  }
+  return matches.reduce((best, m) => {
+    if (m.credits < best.credits) return m;
+    if (m.credits === best.credits && m.score > best.score) return m;
+    return best;
+  }, matches[0]);
+}
+async function formTeam(opts) {
+  const { subtasks, strategy, db, conductorOwner, registryUrl } = opts;
+  const team_id = randomUUID();
+  if (subtasks.length === 0) {
+    return { team_id, strategy, matched: [], unrouted: [] };
+  }
+  const matched = [];
+  const unrouted = [];
+  for (const subtask of subtasks) {
+    const skillCards = getCardsBySkillCapability(db, subtask.required_capability).filter((c) => c.owner !== conductorOwner);
+    if (skillCards.length > 0) {
+      const candidates = skillCards.map((card) => {
+        const skills = card.skills ?? [];
+        const matchingSkill = skills.find(
+          (s) => s.capability_type === subtask.required_capability || (s.capability_types ?? []).includes(subtask.required_capability)
+        );
+        return {
+          subtask_id: subtask.id,
+          selected_agent: card.owner,
+          selected_skill: matchingSkill?.id ?? "",
+          selected_card_id: card.id,
+          score: 1,
+          credits: matchingSkill?.pricing.credits_per_call ?? 0,
+          alternatives: []
+        };
+      });
+      const selected2 = selectByStrategy(candidates, strategy);
+      matched.push({
+        subtask,
+        capability_type: subtask.required_capability,
+        agent: selected2.selected_agent,
+        skill: selected2.selected_skill,
+        card_id: selected2.selected_card_id,
+        credits: selected2.credits,
+        score: selected2.score
+      });
+      continue;
+    }
+    const matchResults = await matchSubTasks({
+      db,
+      subtasks: [subtask],
+      conductorOwner,
+      registryUrl
+    });
+    const m = matchResults[0];
+    if (!m || m.selected_agent === "") {
+      unrouted.push(subtask);
+      continue;
+    }
+    const allCandidates = [
+      m,
+      ...m.alternatives.map((alt) => ({
+        subtask_id: m.subtask_id,
+        selected_agent: alt.agent,
+        selected_skill: alt.skill,
+        score: alt.score,
+        credits: alt.credits,
+        alternatives: []
+      }))
+    ];
+    const selected = selectByStrategy(allCandidates, strategy);
+    matched.push({
+      subtask,
+      capability_type: subtask.required_capability,
+      agent: selected.selected_agent,
+      skill: selected.selected_skill,
+      card_id: selected === m ? m.selected_card_id : void 0,
+      credits: selected.credits,
+      score: selected.score
+    });
+  }
+  return { team_id, strategy, matched, unrouted };
+}
+
+// src/conductor/conductor-mode.ts
+var ConductorMode = class {
+  db;
+  creditDb;
+  conductorOwner;
+  gatewayToken;
+  resolveAgentUrl;
+  maxBudget;
+  constructor(opts) {
+    this.db = opts.db;
+    this.creditDb = opts.creditDb;
+    this.conductorOwner = opts.conductorOwner;
+    this.gatewayToken = opts.gatewayToken;
+    this.resolveAgentUrl = opts.resolveAgentUrl;
+    this.maxBudget = opts.maxBudget ?? 100;
+  }
+  /**
+   * Execute a conductor skill with the given config and params.
+   *
+   * @param config - SkillConfig with type 'conductor' and conductor_skill field.
+   * @param params - Must include `task` string.
+   * @returns Execution result without latency_ms (added by SkillExecutor).
+   */
+  async execute(config, params, onProgress) {
+    const conductorSkill = config.conductor_skill;
+    if (conductorSkill !== "orchestrate" && conductorSkill !== "plan") {
+      return {
+        success: false,
+        error: `Unknown conductor skill: "${conductorSkill}"`
+      };
+    }
+    const task = params.task;
+    if (typeof task !== "string" || task.length === 0) {
+      return {
+        success: false,
+        error: 'Missing or empty "task" parameter'
+      };
+    }
+    const orchestrationDepth = typeof params.orchestration_depth === "number" ? params.orchestration_depth : 0;
+    const decompositionDepth = typeof params.decomposition_depth === "number" ? params.decomposition_depth : 0;
+    if (orchestrationDepth >= 2) {
+      return {
+        success: false,
+        error: "orchestration_depth limit exceeded: max 1 nested orchestration"
+      };
+    }
+    let subtasks = [];
+    if (decompositionDepth === 0) {
+      const allDecomposers = getCardsByCapabilityType(this.db, "task_decomposition");
+      const externalDecomposers = allDecomposers.filter((c) => c.owner !== this.conductorOwner);
+      if (externalDecomposers.length > 0) {
+        const provider = externalDecomposers[0];
+        try {
+          const providerUrl = this.resolveAgentUrl(provider.owner);
+          const response = await requestCapability({
+            gatewayUrl: providerUrl.url,
+            token: this.gatewayToken,
+            cardId: provider.id,
+            params: {
+              task,
+              decomposition_depth: decompositionDepth + 1,
+              orchestration_depth: orchestrationDepth + 1
+            },
+            timeoutMs: 3e4
+          });
+          if (Array.isArray(response)) {
+            const validation = validateAndNormalizeSubtasks(response, {
+              max_credits: this.maxBudget
+            });
+            if (validation.errors.length === 0) {
+              subtasks = validation.valid;
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    if (subtasks.length === 0) {
+      subtasks = decompose(task);
+    }
+    if (subtasks.length === 0) {
+      return {
+        success: false,
+        error: "No template matches task"
+      };
+    }
+    onProgress?.({ step: 1, total: 5, message: `Decomposed into ${subtasks.length} sub-tasks` });
+    const matchResults = await matchSubTasks({
+      db: this.db,
+      subtasks,
+      conductorOwner: this.conductorOwner
+    });
+    onProgress?.({ step: 2, total: 5, message: `Matched ${matchResults.length} sub-tasks to agents` });
+    let team;
+    if (conductorSkill === "orchestrate") {
+      const strategy = typeof params.formation_strategy === "string" && ["cost_optimized", "quality_optimized", "balanced"].includes(params.formation_strategy) ? params.formation_strategy : "balanced";
+      team = await formTeam({
+        subtasks,
+        strategy,
+        db: this.db,
+        conductorOwner: this.conductorOwner
+      });
+      onProgress?.({ step: 2, total: 5, message: `Formed team: ${team.matched.length} members, ${team.unrouted.length} unrouted` });
+    }
+    const budgetManager = new BudgetManager(this.creditDb, this.conductorOwner);
+    const budgetController = new BudgetController(budgetManager, this.maxBudget);
+    const executionBudget = budgetController.calculateBudget(matchResults);
+    if (!budgetController.canExecute(executionBudget)) {
+      return {
+        success: false,
+        error: `Budget exceeded: estimated ${executionBudget.estimated_total} cr, max ${this.maxBudget} cr`
+      };
+    }
+    onProgress?.({ step: 3, total: 5, message: `Budget approved: ${executionBudget.estimated_total} cr` });
+    if (conductorSkill === "plan") {
+      return {
+        success: true,
+        result: {
+          subtasks,
+          matches: matchResults,
+          budget: executionBudget,
+          team
+          // undefined when no role hints
+        }
+      };
+    }
+    const matchMap = new Map(
+      matchResults.map((m) => [m.subtask_id, m])
+    );
+    const orchResult = await orchestrate({
+      subtasks,
+      matches: matchMap,
+      gatewayToken: this.gatewayToken,
+      resolveAgentUrl: this.resolveAgentUrl,
+      maxBudget: this.maxBudget,
+      team
+    });
+    onProgress?.({ step: 4, total: 5, message: "Pipeline execution complete" });
+    const resultObj = {};
+    for (const [key, value] of orchResult.results) {
+      resultObj[key] = value;
+    }
+    return {
+      success: orchResult.success,
+      result: {
+        plan: subtasks,
+        execution: resultObj,
+        total_credits: orchResult.total_credits,
+        latency_ms: orchResult.latency_ms,
+        errors: orchResult.errors
+      },
+      error: orchResult.success ? void 0 : orchResult.errors?.join("; ")
+    };
+  }
+};
+export {
+  ConductorMode
+};

package/dist/{server-MHMAYXWZ.js → server-LMY2A3GT.js}

@@ -32,7 +32,6 @@ import {
 } from "./chunk-WVY2W7AA.js";
 
 // src/mcp/server.ts
-import { createRequire } from "module";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
@@ -254,8 +253,7 @@ function registerPublishTool(server, ctx) {
 }
 
 // src/mcp/server.ts
-var require2 = createRequire(import.meta.url);
-var pkg = require2("../../package.json");
+var VERSION = "8.2.0";
 async function startMcpServer() {
   const config = loadConfig();
   if (!config) {
@@ -266,7 +264,7 @@ async function startMcpServer() {
   const identity = ensureIdentity(configDir, config.owner);
   const server = new McpServer({
     name: "agentbnb",
-    version: pkg.version
+    version: VERSION
   });
   const ctx = {
     configDir,