agentbnb 2.2.0 → 3.0.0

package/dist/card-P5C36VBD.js

@@ -0,0 +1,81 @@
+import {
+  CapabilityCardV2Schema
+} from "./chunk-TQMI73LL.js";
+
+// src/conductor/card.ts
+var CONDUCTOR_OWNER = "agentbnb-conductor";
+var CONDUCTOR_CARD_ID = "00000000-0000-4000-8000-000000000001";
+function buildConductorCard() {
+  const card = {
+    spec_version: "2.0",
+    id: CONDUCTOR_CARD_ID,
+    owner: CONDUCTOR_OWNER,
+    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-BEI5MTNZ.js

@@ -0,0 +1,91 @@
+// 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");
+}
+function getConfigPath() {
+  return join(getConfigDir(), "config.json");
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) return null;
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveConfig(config) {
+  const dir = getConfigDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(getConfigPath(), JSON.stringify(config, null, 2), "utf-8");
+}
+
+// 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 {
+  getConfigDir,
+  loadConfig,
+  saveConfig,
+  loadPeers,
+  savePeer,
+  removePeer,
+  findPeer
+};

package/dist/chunk-EZB4RUIG.js

@@ -0,0 +1,372 @@
+import {
+  interpolateObject,
+  requestCapability,
+  scorePeers,
+  searchCards
+} from "./chunk-V7M6GIJZ.js";
+
+// src/conductor/task-decomposer.ts
+import { randomUUID } from "crypto";
+var TEMPLATES = {
+  "video-production": {
+    keywords: ["video", "demo", "clip", "animation"],
+    steps: [
+      {
+        description: "Generate script from task description",
+        required_capability: "text_gen",
+        estimated_credits: 2,
+        depends_on_indices: []
+      },
+      {
+        description: "Generate voiceover from script",
+        required_capability: "tts",
+        estimated_credits: 3,
+        depends_on_indices: [0]
+      },
+      {
+        description: "Generate video visuals from script",
+        required_capability: "video_gen",
+        estimated_credits: 5,
+        depends_on_indices: [0]
+      },
+      {
+        description: "Composite voiceover and video into final output",
+        required_capability: "video_edit",
+        estimated_credits: 3,
+        depends_on_indices: [1, 2]
+      }
+    ]
+  },
+  "deep-analysis": {
+    keywords: ["analyze", "analysis", "research", "report", "evaluate"],
+    steps: [
+      {
+        description: "Research and gather relevant data",
+        required_capability: "web_search",
+        estimated_credits: 2,
+        depends_on_indices: []
+      },
+      {
+        description: "Analyze gathered data",
+        required_capability: "text_gen",
+        estimated_credits: 3,
+        depends_on_indices: [0]
+      },
+      {
+        description: "Summarize analysis findings",
+        required_capability: "text_gen",
+        estimated_credits: 2,
+        depends_on_indices: [1]
+      },
+      {
+        description: "Format into final report",
+        required_capability: "text_gen",
+        estimated_credits: 1,
+        depends_on_indices: [2]
+      }
+    ]
+  },
+  "content-generation": {
+    keywords: ["write", "blog", "article", "content", "post", "essay"],
+    steps: [
+      {
+        description: "Create content outline",
+        required_capability: "text_gen",
+        estimated_credits: 1,
+        depends_on_indices: []
+      },
+      {
+        description: "Draft content from outline",
+        required_capability: "text_gen",
+        estimated_credits: 3,
+        depends_on_indices: [0]
+      },
+      {
+        description: "Review and refine draft",
+        required_capability: "text_gen",
+        estimated_credits: 2,
+        depends_on_indices: [1]
+      },
+      {
+        description: "Finalize and polish content",
+        required_capability: "text_gen",
+        estimated_credits: 1,
+        depends_on_indices: [2]
+      }
+    ]
+  }
+};
+function decompose(task, _availableCapabilities) {
+  const lower = task.toLowerCase();
+  for (const template of Object.values(TEMPLATES)) {
+    const matched = template.keywords.some((kw) => lower.includes(kw));
+    if (!matched) continue;
+    const ids = template.steps.map(() => randomUUID());
+    return template.steps.map((step, i) => ({
+      id: ids[i],
+      description: step.description,
+      required_capability: step.required_capability,
+      params: {},
+      depends_on: step.depends_on_indices.map((idx) => ids[idx]),
+      estimated_credits: step.estimated_credits
+    }));
+  }
+  return [];
+}
+
+// src/conductor/capability-matcher.ts
+var MAX_ALTERNATIVES = 2;
+function matchSubTasks(opts) {
+  const { db, subtasks, conductorOwner } = opts;
+  return subtasks.map((subtask) => {
+    const cards = searchCards(db, subtask.required_capability, { online: true });
+    const candidates = [];
+    for (const card of cards) {
+      const cardAsV2 = card;
+      if (Array.isArray(cardAsV2.skills)) {
+        for (const skill of cardAsV2.skills) {
+          candidates.push({
+            card,
+            cost: skill.pricing.credits_per_call,
+            skillId: skill.id
+          });
+        }
+      } else {
+        candidates.push({
+          card,
+          cost: card.pricing.credits_per_call,
+          skillId: void 0
+        });
+      }
+    }
+    const scored = scorePeers(candidates, conductorOwner);
+    if (scored.length === 0) {
+      return {
+        subtask_id: subtask.id,
+        selected_agent: "",
+        selected_skill: "",
+        score: 0,
+        credits: 0,
+        alternatives: []
+      };
+    }
+    const top = scored[0];
+    const alternatives = scored.slice(1, 1 + MAX_ALTERNATIVES).map((s) => ({
+      agent: s.card.owner,
+      skill: s.skillId ?? "",
+      score: s.rawScore,
+      credits: s.cost
+    }));
+    return {
+      subtask_id: subtask.id,
+      selected_agent: top.card.owner,
+      selected_skill: top.skillId ?? "",
+      score: top.rawScore,
+      credits: top.cost,
+      alternatives
+    };
+  });
+}
+
+// src/conductor/budget-controller.ts
+var ORCHESTRATION_FEE = 5;
+var BudgetController = class {
+  /**
+   * Creates a new BudgetController.
+   *
+   * @param budgetManager - Underlying BudgetManager for reserve floor enforcement.
+   * @param maxBudget - Hard ceiling for the orchestration run.
+   */
+  constructor(budgetManager, maxBudget) {
+    this.budgetManager = budgetManager;
+    this.maxBudget = maxBudget;
+  }
+  /**
+   * Pre-calculates the total budget for an orchestration run.
+   *
+   * Sums all matched sub-task credits, adds the orchestration fee,
+   * and determines whether approval is required (estimated > max).
+   *
+   * @param matches - MatchResult[] from the CapabilityMatcher.
+   * @returns An ExecutionBudget with cost breakdown and approval status.
+   */
+  calculateBudget(matches) {
+    const perTaskSpending = /* @__PURE__ */ new Map();
+    let subTotal = 0;
+    for (const match of matches) {
+      perTaskSpending.set(match.subtask_id, match.credits);
+      subTotal += match.credits;
+    }
+    const estimatedTotal = subTotal + ORCHESTRATION_FEE;
+    return {
+      estimated_total: estimatedTotal,
+      max_budget: this.maxBudget,
+      orchestration_fee: ORCHESTRATION_FEE,
+      per_task_spending: perTaskSpending,
+      requires_approval: estimatedTotal > this.maxBudget
+    };
+  }
+  /**
+   * Checks whether orchestration can proceed without explicit approval.
+   *
+   * Returns true only when:
+   * 1. The budget does NOT require approval (estimated_total <= max_budget)
+   * 2. The BudgetManager confirms sufficient credits (respecting reserve floor)
+   *
+   * @param budget - ExecutionBudget from calculateBudget().
+   * @returns true if execution can proceed autonomously.
+   */
+  canExecute(budget) {
+    if (budget.requires_approval) return false;
+    return this.budgetManager.canSpend(budget.estimated_total);
+  }
+  /**
+   * Checks budget after explicit user/agent approval.
+   *
+   * Ignores the requires_approval flag — used when the caller has already
+   * obtained explicit approval for the over-budget orchestration.
+   * Still enforces the reserve floor via BudgetManager.canSpend().
+   *
+   * @param budget - ExecutionBudget from calculateBudget().
+   * @returns true if the agent has sufficient credits (reserve floor check only).
+   */
+  approveAndCheck(budget) {
+    return this.budgetManager.canSpend(budget.estimated_total);
+  }
+};
+
+// src/conductor/pipeline-orchestrator.ts
+function computeWaves(subtasks) {
+  const waves = [];
+  const completed = /* @__PURE__ */ new Set();
+  const remaining = new Map(subtasks.map((s) => [s.id, s]));
+  while (remaining.size > 0) {
+    const wave = [];
+    for (const [id, task] of remaining) {
+      const depsResolved = task.depends_on.every((dep) => completed.has(dep));
+      if (depsResolved) {
+        wave.push(id);
+      }
+    }
+    if (wave.length === 0) {
+      break;
+    }
+    for (const id of wave) {
+      remaining.delete(id);
+      completed.add(id);
+    }
+    waves.push(wave);
+  }
+  return waves;
+}
+async function orchestrate(opts) {
+  const { subtasks, matches, gatewayToken, resolveAgentUrl, timeoutMs = 3e4, maxBudget } = opts;
+  const startTime = Date.now();
+  if (subtasks.length === 0) {
+    return {
+      success: true,
+      results: /* @__PURE__ */ new Map(),
+      total_credits: 0,
+      latency_ms: Date.now() - startTime
+    };
+  }
+  const results = /* @__PURE__ */ new Map();
+  const errors = [];
+  let totalCredits = 0;
+  const waves = computeWaves(subtasks);
+  const subtaskMap = new Map(subtasks.map((s) => [s.id, s]));
+  for (const wave of waves) {
+    if (maxBudget !== void 0 && totalCredits >= maxBudget) {
+      errors.push(`Budget exceeded: spent ${totalCredits} cr, max ${maxBudget} cr`);
+      break;
+    }
+    const executableIds = [];
+    for (const taskId of wave) {
+      const m = matches.get(taskId);
+      if (maxBudget !== void 0 && m && totalCredits + m.credits > maxBudget) {
+        errors.push(`Skipping task ${taskId}: would exceed budget (${totalCredits} + ${m.credits} > ${maxBudget})`);
+        continue;
+      }
+      executableIds.push(taskId);
+    }
+    const waveResults = await Promise.allSettled(
+      executableIds.map(async (taskId) => {
+        const subtask = subtaskMap.get(taskId);
+        const m = matches.get(taskId);
+        if (!m) {
+          throw new Error(`No match found for subtask ${taskId}`);
+        }
+        const stepsContext = {};
+        for (const [id, val] of results) {
+          stepsContext[id] = val;
+        }
+        const interpContext = { steps: stepsContext, prev: void 0 };
+        if (subtask.depends_on.length > 0) {
+          const lastDep = subtask.depends_on[subtask.depends_on.length - 1];
+          interpContext.prev = results.get(lastDep);
+        }
+        const interpolatedParams = interpolateObject(
+          subtask.params,
+          interpContext
+        );
+        const primary = resolveAgentUrl(m.selected_agent);
+        try {
+          const res = await requestCapability({
+            gatewayUrl: primary.url,
+            token: gatewayToken,
+            cardId: primary.cardId,
+            params: interpolatedParams,
+            timeoutMs
+          });
+          return { taskId, result: res, credits: m.credits };
+        } catch (primaryErr) {
+          if (m.alternatives.length > 0) {
+            const alt = m.alternatives[0];
+            const altAgent = resolveAgentUrl(alt.agent);
+            try {
+              const altRes = await requestCapability({
+                gatewayUrl: altAgent.url,
+                token: gatewayToken,
+                cardId: altAgent.cardId,
+                params: interpolatedParams,
+                timeoutMs
+              });
+              return { taskId, result: altRes, credits: alt.credits };
+            } catch (altErr) {
+              throw new Error(
+                `Task ${taskId}: primary (${m.selected_agent}) failed: ${primaryErr instanceof Error ? primaryErr.message : String(primaryErr)}; alternative (${alt.agent}) failed: ${altErr instanceof Error ? altErr.message : String(altErr)}`
+              );
+            }
+          }
+          throw new Error(
+            `Task ${taskId}: ${primaryErr instanceof Error ? primaryErr.message : String(primaryErr)}`
+          );
+        }
+      })
+    );
+    for (const settlement of waveResults) {
+      if (settlement.status === "fulfilled") {
+        const { taskId, result, credits } = settlement.value;
+        results.set(taskId, result);
+        totalCredits += credits;
+      } else {
+        errors.push(settlement.reason instanceof Error ? settlement.reason.message : String(settlement.reason));
+      }
+    }
+  }
+  return {
+    success: errors.length === 0,
+    results,
+    total_credits: totalCredits,
+    latency_ms: Date.now() - startTime,
+    errors: errors.length > 0 ? errors : void 0
+  };
+}
+
+export {
+  decompose,
+  matchSubTasks,
+  ORCHESTRATION_FEE,
+  BudgetController,
+  orchestrate
+};