agentbnb 8.2.0 → 8.2.1

package/dist/{chunk-C537SFHV.js → chunk-LOUEJI6X.js}

@@ -1,15 +1,15 @@
 import {
   settleProviderEarning
-} from "./chunk-X32NE6V4.js";
+} from "./chunk-RBXTWWUH.js";
 import {
   getBalance,
   holdEscrow,
   releaseEscrow,
   settleEscrow
-} from "./chunk-D6RKW2XG.js";
+} from "./chunk-JLNHMNES.js";
 import {
   verifyEscrowReceipt
-} from "./chunk-CUONY5TO.js";
+} from "./chunk-EJKW57ZV.js";
 import {
   loadConfig
 } from "./chunk-75OC6E4F.js";
@@ -17,7 +17,7 @@ import {
   getCard,
   insertRequestLog,
   updateReputation
-} from "./chunk-O2OYBAVR.js";
+} from "./chunk-SRBVKO2V.js";
 import {
   AgentBnBError
 } from "./chunk-WVY2W7AA.js";

package/dist/{chunk-ALX4WS3A.js → chunk-NP55V7RQ.js}

@@ -10,7 +10,7 @@ import {
   settleEscrow,
   updateReputation,
   verifyEscrowReceipt
-} from "./chunk-7EF3HYVZ.js";
+} from "./chunk-STJLWMXH.js";
 import {
   loadConfig
 } from "./chunk-IVOYM3WG.js";

package/dist/{chunk-X32NE6V4.js → chunk-RBXTWWUH.js}

@@ -3,7 +3,7 @@ import {
   confirmEscrowDebit,
   recordEarning,
   releaseEscrow
-} from "./chunk-D6RKW2XG.js";
+} from "./chunk-JLNHMNES.js";
 
 // src/credit/settlement.ts
 function settleProviderEarning(providerDb, providerOwner, receipt) {

package/dist/{chunk-O2OYBAVR.js → chunk-SRBVKO2V.js}

@@ -498,6 +498,15 @@ function openDatabase(path = ":memory:") {
       tags,
       content=""
     );
+
+    -- Expression index for capability_type lookups (used by Conductor routing).
+    -- Turns json_extract full-table-scan into O(log n) B-tree lookup.
+    CREATE INDEX IF NOT EXISTS idx_cards_capability_type
+      ON capability_cards(json_extract(data, '$.capability_type'));
+
+    -- Owner index for listCards(owner) and other owner-scoped queries.
+    CREATE INDEX IF NOT EXISTS idx_cards_owner
+      ON capability_cards(owner);
   `);
   createRequestLogTable(db);
   initFeedbackTable(db);

package/dist/{chunk-7EF3HYVZ.js → chunk-STJLWMXH.js}

@@ -502,6 +502,15 @@ function openDatabase(path = ":memory:") {
       tags,
       content=""
     );
+
+    -- Expression index for capability_type lookups (used by Conductor routing).
+    -- Turns json_extract full-table-scan into O(log n) B-tree lookup.
+    CREATE INDEX IF NOT EXISTS idx_cards_capability_type
+      ON capability_cards(json_extract(data, '$.capability_type'));
+
+    -- Owner index for listCards(owner) and other owner-scoped queries.
+    CREATE INDEX IF NOT EXISTS idx_cards_owner
+      ON capability_cards(owner);
   `);
   createRequestLogTable(db);
   initFeedbackTable(db);
@@ -759,6 +768,9 @@ var AGENTS_SCHEMA = `
 function ensureAgentsTable(db) {
   db.exec(AGENTS_SCHEMA);
 }
+function lookupAgent(db, agentId) {
+  return db.prepare("SELECT * FROM agents WHERE agent_id = ?").get(agentId) ?? null;
+}
 
 // src/credit/ledger.ts
 var CREDIT_SCHEMA = `
@@ -839,10 +851,23 @@ function getBalance(db, owner) {
   const row = db.prepare("SELECT balance FROM credit_balances WHERE owner = ?").get(owner);
   return row?.balance ?? 0;
 }
-function getTransactions(db, owner, limit = 100) {
+function getTransactions(db, owner, opts = 100) {
+  const page = typeof opts === "number" ? { limit: opts } : opts;
+  const limit = page.limit ?? 100;
+  const conditions = ["owner = ?"];
+  const params = [owner];
+  if (page.before) {
+    conditions.push("created_at < ?");
+    params.push(page.before);
+  }
+  if (page.after) {
+    conditions.push("created_at > ?");
+    params.push(page.after);
+  }
+  params.push(limit);
   return db.prepare(
-    "SELECT id, owner, amount, reason, reference_id, created_at FROM credit_transactions WHERE owner = ? ORDER BY created_at DESC LIMIT ?"
-  ).all(owner, limit);
+    `SELECT id, owner, amount, reason, reference_id, created_at FROM credit_transactions WHERE ${conditions.join(" AND ")} ORDER BY created_at DESC LIMIT ?`
+  ).all(...params);
 }
 function registerProvider(db, owner) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -1100,7 +1125,25 @@ function loadKeyPair(configDir) {
   };
 }
 function canonicalJson(data) {
-  return JSON.stringify(data, Object.keys(data).sort());
+  return JSON.stringify(sortForCanonicalJson(data));
+}
+function sortForCanonicalJson(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sortForCanonicalJson(item));
+  }
+  if (value !== null && typeof value === "object") {
+    const proto = Object.getPrototypeOf(value);
+    if (proto === Object.prototype || proto === null) {
+      const input = value;
+      const output = {};
+      const sortedKeys = Object.keys(input).sort();
+      for (const key of sortedKeys) {
+        output[key] = sortForCanonicalJson(input[key]);
+      }
+      return output;
+    }
+  }
+  return value;
 }
 function signEscrowReceipt(data, privateKey) {
   const message = Buffer.from(canonicalJson(data), "utf-8");
@@ -1140,6 +1183,7 @@ export {
   listCards,
   getCardsByCapabilityType,
   getCardsBySkillCapability,
+  lookupAgent,
   openCreditDb,
   bootstrapAgent,
   getBalance,

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

@@ -8,16 +8,16 @@ import {
 } from "./chunk-GKVTD4EZ.js";
 import {
   searchCards
-} from "./chunk-LJM7FHPM.js";
+} from "./chunk-BZOJ7HBT.js";
 import {
   getBalance,
   holdEscrow,
   releaseEscrow,
   settleEscrow
-} from "./chunk-D6RKW2XG.js";
+} from "./chunk-JLNHMNES.js";
 import {
   requestCapability
-} from "./chunk-64AK4FJM.js";
+} from "./chunk-EZVOG7QS.js";
 import {
   findPeer
 } from "./chunk-5AH3CMOX.js";

package/dist/{chunk-P4LOYSLA.js → chunk-WKWJWKX7.js}

@@ -8,7 +8,7 @@ import {
   releaseEscrow,
   settleEscrow,
   signEscrowReceipt
-} from "./chunk-7EF3HYVZ.js";
+} from "./chunk-STJLWMXH.js";
 import {
   AgentBnBError
 } from "./chunk-WVY2W7AA.js";
@@ -258,6 +258,13 @@ function decompose(task, _availableCapabilities) {
 
 // src/gateway/client.ts
 import { randomUUID as randomUUID2 } from "crypto";
+import { Agent } from "undici";
+var gatewayAgent = new Agent({
+  keepAliveTimeout: 3e4,
+  keepAliveMaxTimeout: 6e4,
+  connections: 10,
+  pipelining: 1
+});
 async function requestCapability(opts) {
   const { gatewayUrl, token, cardId, params = {}, timeoutMs = 3e5, escrowReceipt, identity } = opts;
   const id = randomUUID2();
@@ -288,7 +295,9 @@ async function requestCapability(opts) {
       method: "POST",
       headers,
       body: JSON.stringify(payload),
-      signal: controller.signal
+      signal: controller.signal,
+      // undici dispatcher for connection pooling (Node.js 20+)
+      dispatcher: gatewayAgent
     });
   } catch (err) {
     clearTimeout(timer);
@@ -306,6 +315,73 @@ async function requestCapability(opts) {
   }
   return body.result;
 }
+async function requestCapabilityBatch(gatewayUrl, token, items, opts = {}) {
+  if (items.length === 0) return /* @__PURE__ */ new Map();
+  if (items.length === 1) {
+    const item = items[0];
+    const result = await requestCapability({
+      gatewayUrl,
+      token,
+      cardId: item.cardId,
+      params: item.params,
+      escrowReceipt: item.escrowReceipt,
+      timeoutMs: opts.timeoutMs,
+      identity: opts.identity
+    });
+    return /* @__PURE__ */ new Map([[item.id, result]]);
+  }
+  const { timeoutMs = 3e5, identity } = opts;
+  const batchPayload = items.map((item) => ({
+    jsonrpc: "2.0",
+    id: item.id,
+    method: "capability.execute",
+    params: {
+      card_id: item.cardId,
+      ...item.params,
+      ...item.escrowReceipt ? { escrow_receipt: item.escrowReceipt } : {}
+    }
+  }));
+  const headers = { "Content-Type": "application/json" };
+  if (identity) {
+    const signature = signEscrowReceipt(batchPayload, identity.privateKey);
+    headers["X-Agent-Id"] = identity.agentId;
+    headers["X-Agent-Public-Key"] = identity.publicKey;
+    headers["X-Agent-Signature"] = signature;
+  } else if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(`${gatewayUrl}/rpc`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(batchPayload),
+      signal: controller.signal,
+      dispatcher: gatewayAgent
+    });
+  } catch (err) {
+    clearTimeout(timer);
+    const isTimeout = err instanceof Error && err.name === "AbortError";
+    throw new AgentBnBError(
+      isTimeout ? "Batch request timed out" : `Network error: ${String(err)}`,
+      isTimeout ? "TIMEOUT" : "NETWORK_ERROR"
+    );
+  } finally {
+    clearTimeout(timer);
+  }
+  const body = await response.json();
+  const results = /* @__PURE__ */ new Map();
+  for (const resp of body) {
+    if (resp.error) {
+      results.set(resp.id, new AgentBnBError(resp.error.message, `RPC_ERROR_${resp.error.code}`));
+    } else {
+      results.set(resp.id, resp.result);
+    }
+  }
+  return results;
+}
 async function requestViaRelay(relay, opts) {
   try {
     return await relay.request({
@@ -376,7 +452,37 @@ function getReputationScore(db, agentId) {
 }
 
 // src/registry/matcher.ts
+var CACHE_MAX_ENTRIES = 100;
+var CACHE_TTL_MS = 3e4;
+var dbCaches = /* @__PURE__ */ new WeakMap();
+function getDbCache(db) {
+  let cache = dbCaches.get(db);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    dbCaches.set(db, cache);
+  }
+  return cache;
+}
+function cacheKey(query, filters) {
+  return `${query}|${filters.level ?? ""}|${filters.online ?? ""}|${(filters.apis_used ?? []).join(",")}|${filters.min_reputation ?? ""}`;
+}
+function evictCache(cache) {
+  const now = Date.now();
+  for (const [key, entry] of cache) {
+    if (entry.expiresAt <= now) cache.delete(key);
+  }
+  while (cache.size > CACHE_MAX_ENTRIES) {
+    const firstKey = cache.keys().next().value;
+    cache.delete(firstKey);
+  }
+}
 function searchCards(db, query, filters = {}) {
+  const cache = getDbCache(db);
+  const key = cacheKey(query, filters);
+  const cached = cache.get(key);
+  if (cached && cached.expiresAt > Date.now()) {
+    return cached.results;
+  }
   const words = query.trim().split(/\s+/).map((w) => w.replace(/["*^{}():]/g, "")).filter((w) => w.length > 0);
   if (words.length === 0) return [];
   const ftsQuery = words.map((w) => `"${w}"`).join(" OR ");
@@ -414,6 +520,8 @@ function searchCards(db, query, filters = {}) {
   if (filters.min_reputation !== void 0 && filters.min_reputation > 0) {
     filtered = applyReputationFilter(db, filtered, filters.min_reputation);
   }
+  evictCache(cache);
+  cache.set(key, { results: filtered, expiresAt: Date.now() + CACHE_TTL_MS });
   return filtered;
 }
 function filterCards(db, filters) {
@@ -1087,6 +1195,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();
@@ -1124,89 +1291,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;