agentbnb 5.1.11 → 7.0.0-beta.1

package/dist/conductor-mode-VGUU54QI.js

@@ -0,0 +1,276 @@
+import {
+  BudgetController,
+  decompose,
+  matchSubTasks,
+  orchestrate,
+  validateAndNormalizeSubtasks
+} from "./chunk-APEG4QIN.js";
+import "./chunk-3MJT4PZG.js";
+import {
+  BudgetManager
+} from "./chunk-GO4FVRVN.js";
+import "./chunk-VMH2YS2I.js";
+import "./chunk-Y7T6IMM3.js";
+import "./chunk-574W3HHE.js";
+import "./chunk-J2K5S5MX.js";
+import "./chunk-NWIQJ2CL.js";
+import {
+  requestCapability
+} from "./chunk-VPQ44XKE.js";
+import "./chunk-F53QQIM2.js";
+import "./chunk-5AH3CMOX.js";
+import "./chunk-75OC6E4F.js";
+import {
+  getCardsByCapabilityType,
+  getCardsBySkillCapability
+} from "./chunk-KA2VIEGM.js";
+import "./chunk-3CIMVISQ.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/execute-I4PKSNJM.js

@@ -0,0 +1,12 @@
+import {
+  executeCapabilityBatch,
+  executeCapabilityRequest
+} from "./chunk-EAD4A4KG.js";
+import "./chunk-K5FO42YF.js";
+import "./chunk-NWIQJ2CL.js";
+import "./chunk-IVOYM3WG.js";
+import "./chunk-3CIMVISQ.js";
+export {
+  executeCapabilityBatch,
+  executeCapabilityRequest
+};

package/dist/execute-MOXSSA3Q.js

@@ -0,0 +1,15 @@
+import {
+  executeCapabilityBatch,
+  executeCapabilityRequest
+} from "./chunk-PGDBUUGR.js";
+import "./chunk-DUW6RX6I.js";
+import "./chunk-J2K5S5MX.js";
+import "./chunk-NWIQJ2CL.js";
+import "./chunk-F53QQIM2.js";
+import "./chunk-75OC6E4F.js";
+import "./chunk-KA2VIEGM.js";
+import "./chunk-3CIMVISQ.js";
+export {
+  executeCapabilityBatch,
+  executeCapabilityRequest
+};