agentbnb 8.2.0 → 8.2.2

package/dist/{chunk-YHY7OG6S.js → chunk-MWOXW7JQ.js}

@@ -1,28 +1,28 @@
-import {
-  RelayClient
-} from "./chunk-Z4MCGKTL.js";
 import {
   BudgetController,
   ORCHESTRATION_FEE,
   decompose,
   matchSubTasks,
   orchestrate
-} from "./chunk-E2OKP5CY.js";
+} from "./chunk-QCGIG7WW.js";
 import {
   BudgetManager
-} from "./chunk-5GME4KJZ.js";
+} from "./chunk-QHZGOG3O.js";
 import {
   openCreditDb
-} from "./chunk-D6RKW2XG.js";
+} from "./chunk-RYISHSHB.js";
 import {
   loadPeers
 } from "./chunk-5AH3CMOX.js";
 import {
   loadConfig
 } from "./chunk-75OC6E4F.js";
+import {
+  RelayClient
+} from "./chunk-Z4MCGKTL.js";
 import {
   openDatabase
-} from "./chunk-O2OYBAVR.js";
+} from "./chunk-S3V6R3EN.js";
 
 // src/cli/conduct.ts
 async function conductAction(task, opts) {

package/dist/{chunk-E2OKP5CY.js → chunk-QCGIG7WW.js}

@@ -3,16 +3,15 @@ import {
 } from "./chunk-3MJT4PZG.js";
 import {
   scorePeers
-} from "./chunk-5GME4KJZ.js";
-import {
-  fetchRemoteCards
-} from "./chunk-KF3TZHA5.js";
+} from "./chunk-QHZGOG3O.js";
 import {
+  fetchRemoteCards,
   searchCards
-} from "./chunk-LJM7FHPM.js";
+} from "./chunk-RYISHSHB.js";
 import {
-  requestCapability
-} from "./chunk-64AK4FJM.js";
+  requestCapability,
+  requestCapabilityBatch
+} from "./chunk-CKOOVZOI.js";
 
 // src/conductor/decomposition-validator.ts
 function validateAndNormalizeSubtasks(raw, context) {
@@ -410,6 +409,65 @@ function computeWaves(subtasks) {
   }
   return waves;
 }
+async function executeSingleTask(pt, gatewayToken, timeoutMs, requesterOwner, relayClient, resolveAgentUrl) {
+  const { taskId, match: m, interpolatedParams, primary, teamId, capabilityType } = pt;
+  try {
+    let res;
+    if (primary.url.startsWith("relay://") && relayClient) {
+      const targetOwner = primary.url.replace("relay://", "");
+      res = await relayClient.request({
+        targetOwner,
+        cardId: primary.cardId,
+        params: interpolatedParams,
+        requester: requesterOwner,
+        timeoutMs
+      });
+    } else {
+      res = await requestCapability({
+        gatewayUrl: primary.url,
+        token: gatewayToken,
+        cardId: primary.cardId,
+        params: { ...interpolatedParams, requester: requesterOwner },
+        timeoutMs
+      });
+    }
+    return { taskId, result: res, credits: m.credits, team_id: teamId, capability_type: capabilityType };
+  } catch (primaryErr) {
+    if (m.alternatives.length > 0) {
+      const alt = m.alternatives[0];
+      const altResolved = resolveAgentUrl ? resolveAgentUrl(alt.agent) : { url: `http://${alt.agent}:7700`, cardId: `card-${alt.agent}` };
+      try {
+        let altRes;
+        if (altResolved.url.startsWith("relay://") && relayClient) {
+          const targetOwner = altResolved.url.replace("relay://", "");
+          altRes = await relayClient.request({
+            targetOwner,
+            cardId: altResolved.cardId,
+            params: interpolatedParams,
+            requester: requesterOwner,
+            timeoutMs
+          });
+        } else {
+          altRes = await requestCapability({
+            gatewayUrl: altResolved.url,
+            token: gatewayToken,
+            cardId: altResolved.cardId,
+            params: { ...interpolatedParams, requester: requesterOwner },
+            timeoutMs
+          });
+        }
+        return { taskId, result: altRes, credits: alt.credits, team_id: teamId, capability_type: capabilityType };
+      } 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)}`
+    );
+  }
+}
 async function orchestrate(opts) {
   const { subtasks, matches, gatewayToken, resolveAgentUrl, timeoutMs = 3e5, maxBudget, relayClient, requesterOwner } = opts;
   const startTime = Date.now();
@@ -447,89 +505,127 @@ async function orchestrate(opts) {
       }
       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 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) {
-            const targetOwner = primary.url.replace("relay://", "");
-            res = await relayClient.request({
-              targetOwner,
-              cardId: primary.cardId,
-              params: interpolatedParams,
-              requester: requesterOwner,
-              timeoutMs
-            });
-          } else {
-            res = await requestCapability({
-              gatewayUrl: primary.url,
-              token: gatewayToken,
-              cardId: primary.cardId,
-              params: { ...interpolatedParams, requester: requesterOwner },
-              timeoutMs
-            });
-          }
-          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];
-            const altAgent = resolveAgentUrl(alt.agent);
+    const preparedTasks = [];
+    for (const taskId of executableIds) {
+      const subtask = subtaskMap.get(taskId);
+      const m = matches.get(taskId);
+      if (!m) {
+        errors.push(`No match found for subtask ${taskId}`);
+        continue;
+      }
+      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 teamMember = teamMemberMap.get(taskId);
+      const agentOwner = teamMember?.agent ?? m.selected_agent;
+      const primary = resolveAgentUrl(agentOwner);
+      preparedTasks.push({
+        taskId,
+        subtask,
+        match: m,
+        interpolatedParams,
+        agentOwner,
+        primary,
+        teamId: opts.team?.team_id ?? null,
+        capabilityType: teamMember?.capability_type ?? null
+      });
+    }
+    const httpGroups = /* @__PURE__ */ new Map();
+    const relayTasks = [];
+    for (const pt of preparedTasks) {
+      if (pt.primary.url.startsWith("relay://") && relayClient) {
+        relayTasks.push(pt);
+      } else {
+        const group = httpGroups.get(pt.primary.url) ?? [];
+        group.push(pt);
+        httpGroups.set(pt.primary.url, group);
+      }
+    }
+    const batchPromises = [];
+    for (const [gatewayUrl, group] of httpGroups) {
+      if (group.length >= 2) {
+        batchPromises.push(
+          (async () => {
+            const items = group.map((pt) => ({
+              id: pt.taskId,
+              cardId: pt.primary.cardId,
+              params: { ...pt.interpolatedParams, requester: requesterOwner },
+              _pt: pt
+            }));
             try {
-              let altRes;
-              if (altAgent.url.startsWith("relay://") && relayClient) {
-                const targetOwner = altAgent.url.replace("relay://", "");
-                altRes = await relayClient.request({
-                  targetOwner,
-                  cardId: altAgent.cardId,
-                  params: interpolatedParams,
-                  requester: requesterOwner,
-                  timeoutMs
-                });
-              } else {
-                altRes = await requestCapability({
-                  gatewayUrl: altAgent.url,
-                  token: gatewayToken,
-                  cardId: altAgent.cardId,
-                  params: { ...interpolatedParams, requester: requesterOwner },
-                  timeoutMs
-                });
-              }
-              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)}`
+              const batchResults = await requestCapabilityBatch(
+                gatewayUrl,
+                gatewayToken,
+                items.map(({ _pt, ...item }) => item),
+                { timeoutMs }
               );
+              return items.map((item) => {
+                const res = batchResults.get(item.id);
+                if (res instanceof Error) {
+                  return {
+                    status: "rejected",
+                    reason: new Error(`Task ${item.id}: ${res.message}`)
+                  };
+                }
+                return {
+                  status: "fulfilled",
+                  value: {
+                    taskId: item.id,
+                    result: res,
+                    credits: item._pt.match.credits,
+                    team_id: item._pt.teamId,
+                    capability_type: item._pt.capabilityType
+                  }
+                };
+              });
+            } catch (batchErr) {
+              return Promise.all(group.map(async (pt) => {
+                try {
+                  const res = await executeSingleTask(pt, gatewayToken, timeoutMs, requesterOwner, relayClient, resolveAgentUrl);
+                  return { status: "fulfilled", value: res };
+                } catch (err) {
+                  return { status: "rejected", reason: err };
+                }
+              }));
+            }
+          })()
+        );
+      } else {
+        const pt = group[0];
+        batchPromises.push(
+          (async () => {
+            try {
+              const res = await executeSingleTask(pt, gatewayToken, timeoutMs, requesterOwner, relayClient, resolveAgentUrl);
+              return [{ status: "fulfilled", value: res }];
+            } catch (err) {
+              return [{ status: "rejected", reason: err }];
             }
+          })()
+        );
+      }
+    }
+    for (const pt of relayTasks) {
+      batchPromises.push(
+        (async () => {
+          try {
+            const res = await executeSingleTask(pt, gatewayToken, timeoutMs, requesterOwner, relayClient, resolveAgentUrl);
+            return [{ status: "fulfilled", value: res }];
+          } catch (err) {
+            return [{ status: "rejected", reason: err }];
           }
-          throw new Error(
-            `Task ${taskId}: ${primaryErr instanceof Error ? primaryErr.message : String(primaryErr)}`
-          );
-        }
-      })
-    );
+        })()
+      );
+    }
+    const allBatchResults = await Promise.all(batchPromises);
+    const waveResults = allBatchResults.flat();
     for (const settlement of waveResults) {
       if (settlement.status === "fulfilled") {
         const { taskId, result, credits, team_id, capability_type } = settlement.value;

package/dist/{chunk-5GME4KJZ.js → chunk-QHZGOG3O.js}

@@ -1,23 +1,23 @@
-import {
-  fetchRemoteCards
-} from "./chunk-KF3TZHA5.js";
 import {
   createPendingRequest,
   getAutonomyTier,
   insertAuditEvent
 } from "./chunk-GKVTD4EZ.js";
 import {
-  searchCards
-} from "./chunk-LJM7FHPM.js";
+  resolveTargetCapability
+} from "./chunk-CQFBNTGT.js";
 import {
+  fetchRemoteCards,
   getBalance,
   holdEscrow,
   releaseEscrow,
+  searchCards,
   settleEscrow
-} from "./chunk-D6RKW2XG.js";
+} from "./chunk-RYISHSHB.js";
 import {
-  requestCapability
-} from "./chunk-64AK4FJM.js";
+  requestCapability,
+  requestViaRelay
+} from "./chunk-CKOOVZOI.js";
 import {
   findPeer
 } from "./chunk-5AH3CMOX.js";
@@ -68,6 +68,7 @@ var BudgetManager = class {
 };
 
 // src/autonomy/auto-request.ts
+import { randomUUID } from "crypto";
 function minMaxNormalize(values) {
   if (values.length === 0) return [];
   if (values.length === 1) return [1];
@@ -190,88 +191,189 @@ var AutoRequestor = class {
       }
     }
     const scored = scorePeers(candidates, this.owner);
+    const resolverOptions = {
+      registryDb: this.registryDb,
+      registryUrl: this.registryUrl,
+      onlineOnly: true
+    };
+    let resolvedTarget = null;
     if (scored.length === 0) {
+      resolvedTarget = await resolveTargetCapability(need.query, resolverOptions);
+      if (!resolvedTarget || resolvedTarget.owner === this.owner || resolvedTarget.credits_per_call > need.maxCostCredits) {
+        this.logFailure("auto_request_failed", "system", "none", 3, 0, "none", "No eligible peer found");
+        return { status: "no_peer", reason: "No eligible peer found" };
+      }
+    } else {
+      const top = scored[0];
+      const targetKey = top.skillId ?? top.card.id;
+      resolvedTarget = await resolveTargetCapability(targetKey, resolverOptions) ?? await resolveTargetCapability(need.query, resolverOptions);
+      if (!resolvedTarget || resolvedTarget.owner === this.owner) {
+        this.logFailure("auto_request_failed", top.card.id, top.skillId ?? "none", 3, top.cost, top.card.owner, "No eligible peer found");
+        return { status: "no_peer", reason: "No eligible peer found" };
+      }
+    }
+    if (!resolvedTarget) {
       this.logFailure("auto_request_failed", "system", "none", 3, 0, "none", "No eligible peer found");
       return { status: "no_peer", reason: "No eligible peer found" };
     }
-    const top = scored[0];
-    const peerConfig = findPeer(top.card.owner);
-    if (!peerConfig) {
-      this.logFailure("auto_request_failed", top.card.id, top.skillId ?? "none", 3, top.cost, top.card.owner, "No gateway config for peer");
-      return { status: "no_peer", reason: "No gateway config for peer" };
-    }
-    const tier = getAutonomyTier(top.cost, this.autonomyConfig);
+    const selectedCardId = resolvedTarget.cardId;
+    const selectedSkillId = resolvedTarget.skillId;
+    const selectedPeer = resolvedTarget.owner;
+    const selectedCost = resolvedTarget.credits_per_call;
+    const selectedViaRelay = resolvedTarget.via_relay;
+    const tier = getAutonomyTier(selectedCost, this.autonomyConfig);
     if (tier === 3) {
       createPendingRequest(this.registryDb, {
         skill_query: need.query,
         max_cost_credits: need.maxCostCredits,
-        credits: top.cost,
-        selected_peer: top.card.owner,
-        selected_card_id: top.card.id,
-        selected_skill_id: top.skillId,
+        credits: selectedCost,
+        selected_peer: selectedPeer,
+        selected_card_id: selectedCardId,
+        selected_skill_id: selectedSkillId,
         params: need.params
       });
       insertAuditEvent(this.registryDb, {
         type: "auto_request_pending",
-        card_id: top.card.id,
-        skill_id: top.skillId ?? top.card.id,
+        card_id: selectedCardId,
+        skill_id: selectedSkillId ?? selectedCardId,
         tier_invoked: 3,
-        credits: top.cost,
-        peer: top.card.owner
+        credits: selectedCost,
+        peer: selectedPeer
       });
       return {
         status: "tier_blocked",
         reason: "Tier 3: owner approval required",
-        peer: top.card.owner
+        peer: selectedPeer
       };
     }
-    if (!this.budgetManager.canSpend(top.cost)) {
-      this.logFailure("auto_request_failed", top.card.id, top.skillId ?? "none", tier, top.cost, top.card.owner, "Budget reserve would be breached");
+    if (!this.budgetManager.canSpend(selectedCost)) {
+      this.logFailure(
+        "auto_request_failed",
+        selectedCardId,
+        selectedSkillId ?? "none",
+        tier,
+        selectedCost,
+        selectedPeer,
+        "Budget reserve would be breached"
+      );
       return { status: "budget_blocked", reason: "Insufficient credits \u2014 reserve floor would be breached" };
     }
-    const escrowId = holdEscrow(this.creditDb, this.owner, top.cost, top.card.id);
+    const escrowId = holdEscrow(this.creditDb, this.owner, selectedCost, selectedCardId);
     try {
-      const execResult = await requestCapability({
-        gatewayUrl: peerConfig.url,
-        token: peerConfig.token,
-        cardId: top.card.id,
-        params: top.skillId ? { skill_id: top.skillId, ...need.params, requester: this.owner } : { ...need.params, requester: this.owner }
-      });
-      settleEscrow(this.creditDb, escrowId, top.card.owner);
+      const requestParams = selectedSkillId ? { skill_id: selectedSkillId, ...need.params, requester: this.owner } : { ...need.params, requester: this.owner };
+      let execResult;
+      if (selectedViaRelay) {
+        if (!this.registryUrl) {
+          this.logFailure(
+            "auto_request_failed",
+            selectedCardId,
+            selectedSkillId ?? "none",
+            tier,
+            selectedCost,
+            selectedPeer,
+            "Relay target found but registryUrl is not configured"
+          );
+          releaseEscrow(this.creditDb, escrowId);
+          return { status: "no_peer", reason: "Relay target found but registryUrl is not configured" };
+        }
+        const relayRequesterOwner = `${this.owner}:req:${randomUUID()}`;
+        const { RelayClient } = await import("./websocket-client-QOVARTRN.js");
+        const relayClient = new RelayClient({
+          registryUrl: this.registryUrl,
+          owner: relayRequesterOwner,
+          token: "auto-request-token",
+          card: {
+            spec_version: "1.0",
+            id: randomUUID(),
+            owner: relayRequesterOwner,
+            name: relayRequesterOwner,
+            description: "Auto-request requester",
+            level: 1,
+            inputs: [],
+            outputs: [],
+            pricing: { credits_per_call: 1 },
+            availability: { online: false }
+          },
+          onRequest: async () => ({ error: { code: -32601, message: "Auto-request relay requester does not serve capabilities" } }),
+          silent: true
+        });
+        try {
+          await relayClient.connect();
+          execResult = await requestViaRelay(relayClient, {
+            targetOwner: selectedPeer,
+            cardId: selectedCardId,
+            skillId: selectedSkillId,
+            params: requestParams,
+            requester: this.owner
+          });
+        } finally {
+          relayClient.disconnect();
+        }
+      } else {
+        const peerConfig = findPeer(selectedPeer);
+        if (!peerConfig) {
+          this.logFailure(
+            "auto_request_failed",
+            selectedCardId,
+            selectedSkillId ?? "none",
+            tier,
+            selectedCost,
+            selectedPeer,
+            "No gateway config for peer"
+          );
+          releaseEscrow(this.creditDb, escrowId);
+          return { status: "no_peer", reason: "No gateway config for peer" };
+        }
+        execResult = await requestCapability({
+          gatewayUrl: peerConfig.url,
+          token: peerConfig.token,
+          cardId: selectedCardId,
+          params: requestParams
+        });
+      }
+      settleEscrow(this.creditDb, escrowId, selectedPeer);
       if (tier === 2) {
         insertAuditEvent(this.registryDb, {
           type: "auto_request_notify",
-          card_id: top.card.id,
-          skill_id: top.skillId ?? top.card.id,
+          card_id: selectedCardId,
+          skill_id: selectedSkillId ?? selectedCardId,
           tier_invoked: 2,
-          credits: top.cost,
-          peer: top.card.owner
+          credits: selectedCost,
+          peer: selectedPeer
         });
       } else {
         insertAuditEvent(this.registryDb, {
           type: "auto_request",
-          card_id: top.card.id,
-          skill_id: top.skillId ?? top.card.id,
+          card_id: selectedCardId,
+          skill_id: selectedSkillId ?? selectedCardId,
           tier_invoked: 1,
-          credits: top.cost,
-          peer: top.card.owner
+          credits: selectedCost,
+          peer: selectedPeer
         });
       }
       return {
         status: "success",
         result: execResult,
         escrowId,
-        peer: top.card.owner,
-        creditsSpent: top.cost
+        peer: selectedPeer,
+        creditsSpent: selectedCost
       };
     } catch (err) {
       releaseEscrow(this.creditDb, escrowId);
       const reason = err instanceof Error ? err.message : String(err);
-      this.logFailure("auto_request_failed", top.card.id, top.skillId ?? "none", tier, top.cost, top.card.owner, `Execution failed: ${reason}`);
+      this.logFailure(
+        "auto_request_failed",
+        selectedCardId,
+        selectedSkillId ?? "none",
+        tier,
+        selectedCost,
+        selectedPeer,
+        `Execution failed: ${reason}`
+      );
       return {
         status: "failed",
         reason: `Execution failed: ${reason}`,
-        peer: top.card.owner
+        peer: selectedPeer
       };
     }
   }