agentbnb 8.2.1 → 8.2.2

package/dist/{chunk-UYCD3JBZ.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-BZOJ7HBT.js";
+  resolveTargetCapability
+} from "./chunk-CQFBNTGT.js";
 import {
+  fetchRemoteCards,
   getBalance,
   holdEscrow,
   releaseEscrow,
+  searchCards,
   settleEscrow
-} from "./chunk-JLNHMNES.js";
+} from "./chunk-RYISHSHB.js";
 import {
-  requestCapability
-} from "./chunk-EZVOG7QS.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
       };
     }
   }

package/dist/{chunk-JLNHMNES.js → chunk-RYISHSHB.js}

@@ -2,6 +2,9 @@ import {
   ensureReliabilityTable,
   recordSuccessfulHire
 } from "./chunk-NWIQJ2CL.js";
+import {
+  getFeedbackForProvider
+} from "./chunk-S3V6R3EN.js";
 import {
   AgentBnBError
 } from "./chunk-WVY2W7AA.js";
@@ -390,6 +393,282 @@ function confirmEscrowDebit(db, escrowId) {
   confirm();
 }
 
+// src/feedback/reputation.ts
+var QUALITY_SCORES = {
+  excellent: 1,
+  good: 0.8,
+  acceptable: 0.6,
+  poor: 0.3,
+  failed: 0
+};
+var COST_VALUE_SCORES = {
+  great: 1,
+  fair: 0.6,
+  overpriced: 0.2
+};
+var DECAY_DAYS = 30;
+var WEIGHTS = {
+  rating: 0.4,
+  quality: 0.3,
+  would_reuse: 0.2,
+  cost_value: 0.1
+};
+function computeReputation(feedbacks) {
+  if (feedbacks.length === 0) return 0.5;
+  const now = Date.now();
+  let weightedSum = 0;
+  let totalWeight = 0;
+  for (const fb of feedbacks) {
+    const feedbackDate = new Date(fb.timestamp).getTime();
+    const ageDays = Math.max(0, (now - feedbackDate) / (1e3 * 60 * 60 * 24));
+    const recencyWeight = Math.exp(-ageDays / DECAY_DAYS);
+    const ratingScore = (fb.rating - 1) / 4;
+    const qualityScore = QUALITY_SCORES[fb.result_quality];
+    const reuseScore = fb.would_reuse ? 1 : 0;
+    const costScore = COST_VALUE_SCORES[fb.cost_value_ratio];
+    const componentScore = WEIGHTS.rating * ratingScore + WEIGHTS.quality * qualityScore + WEIGHTS.would_reuse * reuseScore + WEIGHTS.cost_value * costScore;
+    weightedSum += recencyWeight * componentScore;
+    totalWeight += recencyWeight;
+  }
+  if (totalWeight === 0) return 0.5;
+  const raw = weightedSum / totalWeight;
+  return Math.max(0, Math.min(1, raw));
+}
+function getReputationScore(db, agentId) {
+  const feedbacks = getFeedbackForProvider(db, agentId);
+  return computeReputation(feedbacks);
+}
+
+// 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 trimmedQuery = query.trim();
+  const exactSkillMatches = findCardsByExactSkillId(db, trimmedQuery, filters);
+  const words = query.trim().split(/\s+/).map((w) => w.replace(/["*^{}():]/g, "")).filter((w) => w.length > 0);
+  if (words.length === 0) {
+    return exactSkillMatches;
+  }
+  const ftsQuery = words.map((w) => `"${w}"`).join(" OR ");
+  const conditions = [];
+  const params = [ftsQuery];
+  if (filters.level !== void 0) {
+    conditions.push(`json_extract(cc.data, '$.level') = ?`);
+    params.push(filters.level);
+  }
+  if (filters.online !== void 0) {
+    conditions.push(`json_extract(cc.data, '$.availability.online') = ?`);
+    params.push(filters.online ? 1 : 0);
+  }
+  const whereClause = conditions.length > 0 ? `AND ${conditions.join(" AND ")}` : "";
+  const sql = `
+    SELECT cc.data
+    FROM capability_cards cc
+    JOIN cards_fts ON cc.rowid = cards_fts.rowid
+    WHERE cards_fts MATCH ?
+      ${whereClause}
+    ORDER BY bm25(cards_fts)
+    LIMIT 50
+  `;
+  const stmt = db.prepare(sql);
+  const rows = stmt.all(...params);
+  const results = rows.map((row) => JSON.parse(row.data));
+  const mergedResults = mergeByCardId(exactSkillMatches, results);
+  let filtered = mergedResults;
+  if (filters.apis_used && filters.apis_used.length > 0) {
+    const requiredApis = filters.apis_used;
+    filtered = filtered.filter((card) => {
+      const cardApis = card.metadata?.apis_used ?? [];
+      return requiredApis.every((api) => cardApis.includes(api));
+    });
+  }
+  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 mergeByCardId(primary, secondary) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const card of primary) {
+    if (seen.has(card.id)) continue;
+    seen.add(card.id);
+    merged.push(card);
+  }
+  for (const card of secondary) {
+    if (seen.has(card.id)) continue;
+    seen.add(card.id);
+    merged.push(card);
+  }
+  return merged;
+}
+function findCardsByExactSkillId(db, query, filters) {
+  if (query.length === 0) return [];
+  const rows = db.prepare("SELECT data FROM capability_cards").all();
+  const cards = rows.map((row) => JSON.parse(row.data));
+  return cards.filter((card) => {
+    if (filters.level !== void 0 && card.level !== filters.level) return false;
+    if (filters.online !== void 0 && card.availability?.online !== filters.online) return false;
+    const asRecord = card;
+    const skills = asRecord["skills"];
+    if (!Array.isArray(skills)) return false;
+    return skills.some((skill) => String(skill["id"] ?? "") === query);
+  });
+}
+function filterCards(db, filters) {
+  const conditions = [];
+  const params = [];
+  if (filters.level !== void 0) {
+    conditions.push(`json_extract(data, '$.level') = ?`);
+    params.push(filters.level);
+  }
+  if (filters.online !== void 0) {
+    conditions.push(`json_extract(data, '$.availability.online') = ?`);
+    params.push(filters.online ? 1 : 0);
+  }
+  const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const sql = `SELECT data FROM capability_cards ${whereClause}`;
+  const stmt = db.prepare(sql);
+  const rows = stmt.all(...params);
+  let cards = rows.map((row) => JSON.parse(row.data));
+  if (filters.min_reputation !== void 0 && filters.min_reputation > 0) {
+    cards = applyReputationFilter(db, cards, filters.min_reputation);
+  }
+  return cards;
+}
+function applyReputationFilter(db, cards, minReputation) {
+  const owners = [...new Set(cards.map((c) => c.owner))];
+  const reputationMap = /* @__PURE__ */ new Map();
+  for (const owner of owners) {
+    reputationMap.set(owner, getReputationScore(db, owner));
+  }
+  return cards.filter((card) => {
+    const score = reputationMap.get(card.owner) ?? 0.5;
+    return score >= minReputation;
+  });
+}
+function buildReputationMap(db, owners) {
+  const unique = [...new Set(owners)];
+  const map = /* @__PURE__ */ new Map();
+  for (const owner of unique) {
+    map.set(owner, getReputationScore(db, owner));
+  }
+  return map;
+}
+
+// src/cli/remote-registry.ts
+var RegistryTimeoutError = class extends AgentBnBError {
+  constructor(url) {
+    super(
+      `Registry at ${url} did not respond within 5s. Showing local results only.`,
+      "REGISTRY_TIMEOUT"
+    );
+    this.name = "RegistryTimeoutError";
+  }
+};
+var RegistryConnectionError = class extends AgentBnBError {
+  constructor(url) {
+    super(
+      `Cannot reach ${url}. Is the registry running? Showing local results only.`,
+      "REGISTRY_CONNECTION"
+    );
+    this.name = "RegistryConnectionError";
+  }
+};
+var RegistryAuthError = class extends AgentBnBError {
+  constructor(url) {
+    super(
+      `Authentication failed for ${url}. Run \`agentbnb config set token <your-token>\`.`,
+      "REGISTRY_AUTH"
+    );
+    this.name = "RegistryAuthError";
+  }
+};
+async function fetchRemoteCards(registryUrl, params, timeoutMs = 5e3) {
+  let cardsUrl;
+  try {
+    cardsUrl = new URL("/cards", registryUrl);
+  } catch {
+    throw new AgentBnBError(`Invalid registry URL: ${registryUrl}`, "INVALID_REGISTRY_URL");
+  }
+  const searchParams = new URLSearchParams();
+  if (params.q !== void 0) searchParams.set("q", params.q);
+  if (params.level !== void 0) searchParams.set("level", String(params.level));
+  if (params.online !== void 0) searchParams.set("online", String(params.online));
+  if (params.tag !== void 0) searchParams.set("tag", params.tag);
+  searchParams.set("limit", "100");
+  cardsUrl.search = searchParams.toString();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(cardsUrl.toString(), { signal: controller.signal });
+  } catch (err) {
+    clearTimeout(timer);
+    const isTimeout = err instanceof Error && err.name === "AbortError";
+    if (isTimeout) {
+      throw new RegistryTimeoutError(registryUrl);
+    }
+    throw new RegistryConnectionError(registryUrl);
+  } finally {
+    clearTimeout(timer);
+  }
+  if (response.status === 401 || response.status === 403) {
+    throw new RegistryAuthError(registryUrl);
+  }
+  if (!response.ok) {
+    throw new RegistryConnectionError(registryUrl);
+  }
+  const body = await response.json();
+  return body.items;
+}
+function mergeResults(localCards, remoteCards, hasQuery) {
+  const taggedLocal = localCards.map((c) => ({ ...c, source: "local" }));
+  const taggedRemote = remoteCards.map((c) => ({ ...c, source: "remote" }));
+  const localIds = new Set(localCards.map((c) => c.id));
+  const dedupedRemote = taggedRemote.filter((c) => !localIds.has(c.id));
+  if (!hasQuery) {
+    return [...taggedLocal, ...dedupedRemote];
+  }
+  const result = [];
+  const maxLen = Math.max(taggedLocal.length, dedupedRemote.length);
+  for (let i = 0; i < maxLen; i++) {
+    if (i < taggedLocal.length) result.push(taggedLocal[i]);
+    if (i < dedupedRemote.length) result.push(dedupedRemote[i]);
+  }
+  return result;
+}
+
 export {
   createAgentRecord,
   lookupAgent,
@@ -404,5 +683,11 @@ export {
   holdEscrow,
   settleEscrow,
   releaseEscrow,
-  confirmEscrowDebit
+  confirmEscrowDebit,
+  computeReputation,
+  searchCards,
+  filterCards,
+  buildReputationMap,
+  fetchRemoteCards,
+  mergeResults
 };