agentbnb 5.1.11 → 7.0.0-beta.1

package/dist/{client-T5MTY3CS.js → client-HRYRJKSA.js}

@@ -1,9 +1,9 @@
 import {
   requestCapability,
   requestViaRelay
-} from "./chunk-XND2DWTZ.js";
-import "./chunk-5KFI5X7B.js";
-import "./chunk-WGZ5AGOX.js";
+} from "./chunk-VPQ44XKE.js";
+import "./chunk-F53QQIM2.js";
+import "./chunk-3CIMVISQ.js";
 export {
   requestCapability,
   requestViaRelay

package/dist/{conduct-WU3VEXB6.js → conduct-JNYJCDHQ.js}

@@ -1,21 +1,22 @@
 import {
   conductAction
-} from "./chunk-NLAWT4DT.js";
-import "./chunk-JOY533UH.js";
-import "./chunk-QT7TEVNV.js";
-import "./chunk-WTXRY7R2.js";
+} from "./chunk-CWYPTQRQ.js";
+import "./chunk-TW65F5EU.js";
+import "./chunk-EHSHB7TY.js";
+import "./chunk-APEG4QIN.js";
 import "./chunk-3MJT4PZG.js";
-import "./chunk-EGUOAHCW.js";
-import "./chunk-CSATDXZC.js";
-import "./chunk-ZX5623ER.js";
-import "./chunk-NH2FIERR.js";
-import "./chunk-XND2DWTZ.js";
+import "./chunk-GO4FVRVN.js";
+import "./chunk-VMH2YS2I.js";
+import "./chunk-Y7T6IMM3.js";
+import "./chunk-574W3HHE.js";
+import "./chunk-J2K5S5MX.js";
+import "./chunk-NWIQJ2CL.js";
+import "./chunk-VPQ44XKE.js";
+import "./chunk-F53QQIM2.js";
 import "./chunk-5AH3CMOX.js";
 import "./chunk-75OC6E4F.js";
-import "./chunk-DFBX3BBD.js";
-import "./chunk-EANI2N2V.js";
-import "./chunk-5KFI5X7B.js";
-import "./chunk-WGZ5AGOX.js";
+import "./chunk-KA2VIEGM.js";
+import "./chunk-3CIMVISQ.js";
 
 // src/mcp/tools/conduct.ts
 import { z } from "zod";

package/dist/conduct-KJUD2RTB.js

@@ -0,0 +1,22 @@
+import {
+  conductAction
+} from "./chunk-CWYPTQRQ.js";
+import "./chunk-TW65F5EU.js";
+import "./chunk-EHSHB7TY.js";
+import "./chunk-APEG4QIN.js";
+import "./chunk-3MJT4PZG.js";
+import "./chunk-GO4FVRVN.js";
+import "./chunk-VMH2YS2I.js";
+import "./chunk-Y7T6IMM3.js";
+import "./chunk-574W3HHE.js";
+import "./chunk-J2K5S5MX.js";
+import "./chunk-NWIQJ2CL.js";
+import "./chunk-VPQ44XKE.js";
+import "./chunk-F53QQIM2.js";
+import "./chunk-5AH3CMOX.js";
+import "./chunk-75OC6E4F.js";
+import "./chunk-KA2VIEGM.js";
+import "./chunk-3CIMVISQ.js";
+export {
+  conductAction
+};

package/dist/{conductor-mode-ZMTFZGJP.js → conductor-mode-2VVFMKVE.js}

@@ -3,16 +3,155 @@ import {
   interpolateObject,
   requestCapability,
   searchCards
-} from "./chunk-B5FTAGFN.js";
+} from "./chunk-ETGOKDFR.js";
 import "./chunk-HLUEOLSZ.js";
-import "./chunk-IVOYM3WG.js";
 import {
-  getBalance
-} from "./chunk-CRFCWD6V.js";
-import "./chunk-WGZ5AGOX.js";
+  getBalance,
+  getCardsByCapabilityType,
+  getCardsBySkillCapability
+} from "./chunk-K5FO42YF.js";
+import "./chunk-NWIQJ2CL.js";
+import "./chunk-IVOYM3WG.js";
+import "./chunk-3CIMVISQ.js";
 
 // src/conductor/task-decomposer.ts
 import { randomUUID } from "crypto";
+
+// src/conductor/decomposition-validator.ts
+function validateAndNormalizeSubtasks(raw, context) {
+  try {
+    return _validate(raw, context);
+  } catch {
+    return { valid: [], errors: ["internal validation error"] };
+  }
+}
+function _validate(raw, context) {
+  if (!Array.isArray(raw)) {
+    return { valid: [], errors: ["decomposition output must be an array"] };
+  }
+  if (raw.length === 0) {
+    return { valid: [], errors: [] };
+  }
+  const errors = [];
+  const validItems = [];
+  const validIds = [];
+  for (let i = 0; i < raw.length; i++) {
+    const item = raw[i];
+    if (typeof item !== "object" || item === null || Array.isArray(item)) {
+      errors.push(`subtask[${i}]: must be an object`);
+      continue;
+    }
+    const obj = item;
+    let itemValid = true;
+    const id = obj["id"];
+    if (typeof id !== "string" || id.length === 0) {
+      errors.push(`subtask[${i}]: id must be a non-empty string`);
+      itemValid = false;
+    }
+    const description = obj["description"];
+    if (typeof description !== "string" || description.length === 0) {
+      errors.push(`subtask[${i}]: description must be a non-empty string`);
+      itemValid = false;
+    }
+    const required_capability = obj["required_capability"];
+    if (typeof required_capability !== "string" || required_capability.length === 0) {
+      errors.push(`subtask[${i}]: required_capability must be a non-empty string`);
+      itemValid = false;
+    }
+    const estimated_credits = obj["estimated_credits"];
+    if (estimated_credits !== void 0) {
+      if (typeof estimated_credits !== "number" || estimated_credits <= 0) {
+        errors.push(`subtask[${i}]: estimated_credits must be a positive number`);
+        itemValid = false;
+      } else if (estimated_credits > context.max_credits) {
+        errors.push(
+          `subtask[${i}]: estimated_credits ${estimated_credits} exceeds max_credits ${context.max_credits}`
+        );
+        itemValid = false;
+      }
+    }
+    if (itemValid) {
+      validItems.push(obj);
+      validIds.push(id);
+    }
+  }
+  const idSet = /* @__PURE__ */ new Set();
+  for (const id of validIds) {
+    if (idSet.has(id)) {
+      errors.push(`duplicate subtask id: ${id}`);
+    } else {
+      idSet.add(id);
+    }
+  }
+  for (let i = 0; i < validItems.length; i++) {
+    const item = validItems[i];
+    const depends_on = item["depends_on"];
+    if (!Array.isArray(depends_on)) continue;
+    for (const dep of depends_on) {
+      if (typeof dep === "string" && !idSet.has(dep)) {
+        errors.push(`subtask[${i}]: depends_on references unknown id '${dep}'`);
+      }
+    }
+  }
+  if (errors.length === 0 && validItems.length > 0) {
+    const inDegree = /* @__PURE__ */ new Map();
+    const adjList = /* @__PURE__ */ new Map();
+    for (const id of validIds) {
+      inDegree.set(id, 0);
+      adjList.set(id, []);
+    }
+    for (const item of validItems) {
+      const depends_on = item["depends_on"];
+      if (!Array.isArray(depends_on)) continue;
+      for (const dep of depends_on) {
+        if (typeof dep !== "string" || !idSet.has(dep)) continue;
+        adjList.get(dep)?.push(item["id"]);
+        inDegree.set(item["id"], (inDegree.get(item["id"]) ?? 0) + 1);
+      }
+    }
+    const queue = [];
+    for (const [id, deg] of inDegree) {
+      if (deg === 0) queue.push(id);
+    }
+    let processed = 0;
+    while (queue.length > 0) {
+      const current = queue.shift();
+      processed++;
+      for (const neighbor of adjList.get(current) ?? []) {
+        const newDeg = (inDegree.get(neighbor) ?? 0) - 1;
+        inDegree.set(neighbor, newDeg);
+        if (newDeg === 0) queue.push(neighbor);
+      }
+    }
+    if (processed < validItems.length) {
+      for (const [id, deg] of inDegree) {
+        if (deg > 0) {
+          errors.push(`circular dependency detected involving subtask id: ${id}`);
+          break;
+        }
+      }
+    }
+  }
+  if (errors.length > 0) {
+    return { valid: [], errors };
+  }
+  const normalized = validItems.map((item) => {
+    const depends_on = Array.isArray(item["depends_on"]) ? item["depends_on"].filter((x) => typeof x === "string") : [];
+    const params = typeof item["params"] === "object" && item["params"] !== null && !Array.isArray(item["params"]) ? item["params"] : {};
+    const estimated_credits = typeof item["estimated_credits"] === "number" ? item["estimated_credits"] : 0;
+    return {
+      id: item["id"],
+      description: item["description"],
+      required_capability: item["required_capability"],
+      params,
+      depends_on,
+      estimated_credits
+    };
+  });
+  return { valid: normalized, errors: [] };
+}
+
+// src/conductor/task-decomposer.ts
 var TEMPLATES = {
   "video-production": {
     keywords: ["video", "demo", "clip", "animation"],
@@ -150,12 +289,14 @@ function scorePeers(candidates, selfOwner) {
     const idleRate = internal?.["idle_rate"];
     return typeof idleRate === "number" ? idleRate : 1;
   });
+  const loadFactors = eligible.map((c) => c.loadFactor ?? 1);
   const normSuccess = minMaxNormalize(successRates);
   const normCost = minMaxNormalize(costEfficiencies);
   const normIdle = minMaxNormalize(idleRates);
+  const normLoad = minMaxNormalize(loadFactors);
   const scored = eligible.map((c, i) => ({
     ...c,
-    rawScore: (normSuccess[i] ?? 0) * (normCost[i] ?? 0) * (normIdle[i] ?? 0)
+    rawScore: (normSuccess[i] ?? 0) * (normCost[i] ?? 0) * (normIdle[i] ?? 0) * (normLoad[i] ?? 0)
   }));
   scored.sort((a, b) => b.rawScore - a.rawScore);
   return scored;
@@ -362,6 +503,12 @@ function computeWaves(subtasks) {
 async function orchestrate(opts) {
   const { subtasks, matches, gatewayToken, resolveAgentUrl, timeoutMs = 3e5, maxBudget, relayClient, requesterOwner } = opts;
   const startTime = Date.now();
+  const teamMemberMap = /* @__PURE__ */ new Map();
+  if (opts.team) {
+    for (const member of opts.team.matched) {
+      teamMemberMap.set(member.subtask.id, member);
+    }
+  }
   if (subtasks.length === 0) {
     return {
       success: true,
@@ -373,6 +520,7 @@ async function orchestrate(opts) {
   const results = /* @__PURE__ */ new Map();
   const errors = [];
   let totalCredits = 0;
+  const traceContext = /* @__PURE__ */ new Map();
   const waves = computeWaves(subtasks);
   const subtaskMap = new Map(subtasks.map((s) => [s.id, s]));
   for (const wave of waves) {
@@ -409,7 +557,11 @@ async function orchestrate(opts) {
           subtask.params,
           interpContext
         );
-        const primary = resolveAgentUrl(m.selected_agent);
+        const teamMember = teamMemberMap.get(taskId);
+        const teamId = opts.team?.team_id ?? null;
+        const taskCapabilityType = teamMember?.capability_type ?? null;
+        const agentOwner = teamMember?.agent ?? m.selected_agent;
+        const primary = resolveAgentUrl(agentOwner);
         try {
           let res;
           if (primary.url.startsWith("relay://") && relayClient) {
@@ -430,7 +582,7 @@ async function orchestrate(opts) {
               timeoutMs
             });
           }
-          return { taskId, result: res, credits: m.credits };
+          return { taskId, result: res, credits: m.credits, team_id: teamId, capability_type: taskCapabilityType };
         } catch (primaryErr) {
           if (m.alternatives.length > 0) {
             const alt = m.alternatives[0];
@@ -455,7 +607,7 @@ async function orchestrate(opts) {
                   timeoutMs
                 });
               }
-              return { taskId, result: altRes, credits: alt.credits };
+              return { taskId, result: altRes, credits: alt.credits, team_id: teamId, capability_type: taskCapabilityType };
             } 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)}`
@@ -470,9 +622,10 @@ async function orchestrate(opts) {
     );
     for (const settlement of waveResults) {
       if (settlement.status === "fulfilled") {
-        const { taskId, result, credits } = settlement.value;
+        const { taskId, result, credits, team_id, capability_type } = settlement.value;
         results.set(taskId, result);
         totalCredits += credits;
+        traceContext.set(taskId, { team_id: team_id ?? null, capability_type: capability_type ?? null });
       } else {
         errors.push(settlement.reason instanceof Error ? settlement.reason.message : String(settlement.reason));
       }
@@ -483,10 +636,101 @@ async function orchestrate(opts) {
     results,
     total_credits: totalCredits,
     latency_ms: Date.now() - startTime,
-    errors: errors.length > 0 ? errors : void 0
+    errors: errors.length > 0 ? errors : void 0,
+    trace: traceContext.size > 0 ? traceContext : void 0
   };
 }
 
+// src/conductor/team-formation.ts
+import { randomUUID as randomUUID2 } 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 = randomUUID2();
+  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;
@@ -525,7 +769,48 @@ var ConductorMode = class {
         error: 'Missing or empty "task" parameter'
       };
     }
-    const subtasks = decompose(task);
+    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,
@@ -539,6 +824,17 @@ var ConductorMode = class {
       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);
@@ -555,7 +851,9 @@ var ConductorMode = class {
         result: {
           subtasks,
           matches: matchResults,
-          budget: executionBudget
+          budget: executionBudget,
+          team
+          // undefined when no role hints
         }
       };
     }
@@ -567,7 +865,8 @@ var ConductorMode = class {
       matches: matchMap,
       gatewayToken: this.gatewayToken,
       resolveAgentUrl: this.resolveAgentUrl,
-      maxBudget: this.maxBudget
+      maxBudget: this.maxBudget,
+      team
     });
     onProgress?.({ step: 4, total: 5, message: "Pipeline execution complete" });
     const resultObj = {};