agentbnb 2.2.0 → 3.1.0

package/dist/conduct-M57F72RK.js

@@ -0,0 +1,117 @@
+import {
+  BudgetController,
+  ORCHESTRATION_FEE,
+  decompose,
+  matchSubTasks,
+  orchestrate
+} from "./chunk-T7ZJPQHD.js";
+import {
+  BudgetManager
+} from "./chunk-QVIGMCHA.js";
+import {
+  loadConfig,
+  loadPeers
+} from "./chunk-BEI5MTNZ.js";
+import {
+  openDatabase
+} from "./chunk-2LLXUKMY.js";
+import {
+  openCreditDb
+} from "./chunk-ZJCIBK6O.js";
+import "./chunk-TQMI73LL.js";
+
+// 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 = matchSubTasks({
+      db,
+      subtasks,
+      conductorOwner: config.owner
+    });
+  } 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 resolveAgentUrl = (owner) => {
+    const peer = peers.find((p) => p.name.toLowerCase() === owner.toLowerCase());
+    if (!peer) {
+      throw new Error(
+        `Unknown peer "${owner}". Add with: agentbnb peers add ${owner} <url> <token>`
+      );
+    }
+    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();
+    }
+  };
+  const matchMap = new Map(
+    matchResults.map((m) => [m.subtask_id, m])
+  );
+  const orchResult = await orchestrate({
+    subtasks,
+    matches: matchMap,
+    gatewayToken: config.token ?? "",
+    resolveAgentUrl,
+    timeoutMs: 3e4,
+    maxBudget
+  });
+  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
+  };
+}
+export {
+  conductAction
+};

package/dist/conductor-mode-CF6PSRRA.js

@@ -0,0 +1,112 @@
+import {
+  BudgetController,
+  decompose,
+  matchSubTasks,
+  orchestrate
+} from "./chunk-T7ZJPQHD.js";
+import {
+  BudgetManager
+} from "./chunk-QVIGMCHA.js";
+import "./chunk-BEI5MTNZ.js";
+import "./chunk-ZJCIBK6O.js";
+import "./chunk-TQMI73LL.js";
+
+// 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) {
+    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 subtasks = decompose(task);
+    if (subtasks.length === 0) {
+      return {
+        success: false,
+        error: "No template matches task"
+      };
+    }
+    const matchResults = matchSubTasks({
+      db: this.db,
+      subtasks,
+      conductorOwner: this.conductorOwner
+    });
+    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`
+      };
+    }
+    if (conductorSkill === "plan") {
+      return {
+        success: true,
+        result: {
+          subtasks,
+          matches: matchResults,
+          budget: executionBudget
+        }
+      };
+    }
+    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
+    });
+    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/execute-3T5RF3DP.js

@@ -0,0 +1,9 @@
+import {
+  executeCapabilityRequest
+} from "./chunk-4Q7D24DP.js";
+import "./chunk-2LLXUKMY.js";
+import "./chunk-ZJCIBK6O.js";
+import "./chunk-TQMI73LL.js";
+export {
+  executeCapabilityRequest
+};