agentbnb 4.0.4 → 5.1.0

package/dist/chunk-AUBHR7HH.js

@@ -0,0 +1,25 @@
+// src/feedback/schema.ts
+import { z } from "zod";
+var StructuredFeedbackSchema = z.object({
+  transaction_id: z.string().uuid(),
+  // must match a request_log entry id
+  provider_agent: z.string().min(1),
+  skill_id: z.string().min(1),
+  requester_agent: z.string().min(1),
+  rating: z.number().int().min(1).max(5),
+  latency_ms: z.number().int().min(0),
+  result_quality: z.enum(["excellent", "good", "acceptable", "poor", "failed"]),
+  quality_details: z.string().max(500).optional(),
+  would_reuse: z.boolean(),
+  cost_value_ratio: z.enum(["great", "fair", "overpriced"]),
+  timestamp: z.string().datetime()
+});
+var FeedbackResponseSchema = z.object({
+  feedback_id: z.string().uuid(),
+  received_at: z.string().datetime()
+});
+
+export {
+  StructuredFeedbackSchema,
+  FeedbackResponseSchema
+};

package/dist/chunk-B5FTAGFN.js

@@ -0,0 +1,393 @@
+import {
+  getFeedbackForProvider,
+  signEscrowReceipt
+} from "./chunk-CRFCWD6V.js";
+import {
+  AgentBnBError
+} from "./chunk-WGZ5AGOX.js";
+
+// src/utils/interpolation.ts
+function resolvePath(obj, path) {
+  const segments = path.replace(/\[(\d+)\]/g, ".$1").split(".").filter((s) => s.length > 0);
+  let current = obj;
+  for (const segment of segments) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    if (typeof current !== "object") {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function interpolate(template, context) {
+  return template.replace(/\$\{([^}]+)\}/g, (_match, expression) => {
+    const resolved = resolvePath(context, expression.trim());
+    if (resolved === void 0 || resolved === null) {
+      return "";
+    }
+    if (typeof resolved === "object") {
+      return JSON.stringify(resolved);
+    }
+    return String(resolved);
+  });
+}
+function interpolateObject(obj, context) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    result[key] = interpolateValue(value, context);
+  }
+  return result;
+}
+function interpolateValue(value, context) {
+  if (typeof value === "string") {
+    return interpolate(value, context);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => interpolateValue(item, context));
+  }
+  if (value !== null && typeof value === "object") {
+    return interpolateObject(value, context);
+  }
+  return value;
+}
+
+// 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
+function searchCards(db, query, filters = {}) {
+  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 ");
+  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));
+  let filtered = results;
+  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);
+  }
+  return filtered;
+}
+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/gateway/client.ts
+import { randomUUID } from "crypto";
+async function requestCapability(opts) {
+  const { gatewayUrl, token, cardId, params = {}, timeoutMs = 3e5, escrowReceipt, identity } = opts;
+  const id = randomUUID();
+  const payload = {
+    jsonrpc: "2.0",
+    id,
+    method: "capability.execute",
+    params: {
+      card_id: cardId,
+      ...params,
+      ...escrowReceipt ? { escrow_receipt: escrowReceipt } : {}
+    }
+  };
+  const headers = { "Content-Type": "application/json" };
+  if (identity) {
+    const signature = signEscrowReceipt(payload, 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(payload),
+      signal: controller.signal
+    });
+  } catch (err) {
+    clearTimeout(timer);
+    const isTimeout = err instanceof Error && err.name === "AbortError";
+    throw new AgentBnBError(
+      isTimeout ? "Request timed out" : `Network error: ${String(err)}`,
+      isTimeout ? "TIMEOUT" : "NETWORK_ERROR"
+    );
+  } finally {
+    clearTimeout(timer);
+  }
+  const body = await response.json();
+  if (body.error) {
+    throw new AgentBnBError(body.error.message, `RPC_ERROR_${body.error.code}`);
+  }
+  return body.result;
+}
+async function requestViaRelay(relay, opts) {
+  try {
+    return await relay.request({
+      targetOwner: opts.targetOwner,
+      cardId: opts.cardId,
+      skillId: opts.skillId,
+      params: opts.params ?? {},
+      requester: opts.requester,
+      escrowReceipt: opts.escrowReceipt,
+      timeoutMs: opts.timeoutMs
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.includes("timeout")) {
+      throw new AgentBnBError(message, "TIMEOUT");
+    }
+    if (message.includes("offline")) {
+      throw new AgentBnBError(message, "AGENT_OFFLINE");
+    }
+    throw new AgentBnBError(message, "RELAY_ERROR");
+  }
+}
+
+// src/autonomy/tiers.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var DEFAULT_AUTONOMY_CONFIG = {
+  tier1_max_credits: 0,
+  tier2_max_credits: 0
+};
+function getAutonomyTier(creditAmount, config) {
+  if (creditAmount < config.tier1_max_credits) return 1;
+  if (creditAmount < config.tier2_max_credits) return 2;
+  return 3;
+}
+function insertAuditEvent(db, event) {
+  const isShareEvent = event.type === "auto_share" || event.type === "auto_share_notify" || event.type === "auto_share_pending";
+  const cardId = isShareEvent ? "system" : event.card_id;
+  const creditsCharged = isShareEvent ? 0 : event.credits;
+  const stmt = db.prepare(`
+    INSERT INTO request_log (
+      id, card_id, card_name, requester, status, latency_ms, credits_charged,
+      created_at, skill_id, action_type, tier_invoked
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  stmt.run(
+    randomUUID2(),
+    cardId,
+    "autonomy-audit",
+    "self",
+    "success",
+    0,
+    creditsCharged,
+    (/* @__PURE__ */ new Date()).toISOString(),
+    event.skill_id,
+    event.type,
+    event.tier_invoked
+  );
+}
+
+// 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;
+}
+
+// src/autonomy/pending-requests.ts
+import { randomUUID as randomUUID3 } from "crypto";
+function listPendingRequests(db) {
+  const rows = db.prepare(`SELECT * FROM pending_requests WHERE status = 'pending' ORDER BY created_at DESC`).all();
+  return rows;
+}
+function resolvePendingRequest(db, id, resolution) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const result = db.prepare(
+    `UPDATE pending_requests SET status = ?, resolved_at = ? WHERE id = ?`
+  ).run(resolution, now, id);
+  if (result.changes === 0) {
+    throw new AgentBnBError(
+      `Pending request not found: ${id}`,
+      "NOT_FOUND"
+    );
+  }
+}
+
+export {
+  interpolateObject,
+  computeReputation,
+  searchCards,
+  filterCards,
+  buildReputationMap,
+  requestCapability,
+  requestViaRelay,
+  DEFAULT_AUTONOMY_CONFIG,
+  getAutonomyTier,
+  insertAuditEvent,
+  listPendingRequests,
+  resolvePendingRequest,
+  fetchRemoteCards
+};

package/dist/{chunk-GGYC5U2Z.js → chunk-BTTL24TZ.js}

@@ -1,7 +1,14 @@
 import {
-  fetchRemoteCards,
+  createPendingRequest,
+  getAutonomyTier,
+  insertAuditEvent
+} from "./chunk-CSATDXZC.js";
+import {
+  fetchRemoteCards
+} from "./chunk-ZX5623ER.js";
+import {
   searchCards
-} from "./chunk-FF226TIV.js";
+} from "./chunk-NH2FIERR.js";
 import {
   requestCapability
 } from "./chunk-XND2DWTZ.js";
@@ -13,46 +20,7 @@ import {
   holdEscrow,
   releaseEscrow,
   settleEscrow
-} from "./chunk-DNWT5FZQ.js";
-import {
-  AgentBnBError
-} from "./chunk-WGZ5AGOX.js";
-
-// src/autonomy/tiers.ts
-import { randomUUID } from "crypto";
-var DEFAULT_AUTONOMY_CONFIG = {
-  tier1_max_credits: 0,
-  tier2_max_credits: 0
-};
-function getAutonomyTier(creditAmount, config) {
-  if (creditAmount < config.tier1_max_credits) return 1;
-  if (creditAmount < config.tier2_max_credits) return 2;
-  return 3;
-}
-function insertAuditEvent(db, event) {
-  const isShareEvent = event.type === "auto_share" || event.type === "auto_share_notify" || event.type === "auto_share_pending";
-  const cardId = isShareEvent ? "system" : event.card_id;
-  const creditsCharged = isShareEvent ? 0 : event.credits;
-  const stmt = db.prepare(`
-    INSERT INTO request_log (
-      id, card_id, card_name, requester, status, latency_ms, credits_charged,
-      created_at, skill_id, action_type, tier_invoked
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `);
-  stmt.run(
-    randomUUID(),
-    cardId,
-    "autonomy-audit",
-    "self",
-    "success",
-    0,
-    creditsCharged,
-    (/* @__PURE__ */ new Date()).toISOString(),
-    event.skill_id,
-    event.type,
-    event.tier_invoked
-  );
-}
+} from "./chunk-EANI2N2V.js";
 
 // src/credit/budget.ts
 var DEFAULT_BUDGET_CONFIG = {
@@ -99,47 +67,6 @@ var BudgetManager = class {
   }
 };
 
-// src/autonomy/pending-requests.ts
-import { randomUUID as randomUUID2 } from "crypto";
-function createPendingRequest(db, opts) {
-  const id = randomUUID2();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const paramsJson = opts.params !== void 0 ? JSON.stringify(opts.params) : null;
-  db.prepare(`
-    INSERT INTO pending_requests (
-      id, skill_query, max_cost_credits, selected_peer, selected_card_id,
-      selected_skill_id, credits, status, params, created_at, resolved_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?, NULL)
-  `).run(
-    id,
-    opts.skill_query,
-    opts.max_cost_credits,
-    opts.selected_peer ?? null,
-    opts.selected_card_id ?? null,
-    opts.selected_skill_id ?? null,
-    opts.credits,
-    paramsJson,
-    now
-  );
-  return id;
-}
-function listPendingRequests(db) {
-  const rows = db.prepare(`SELECT * FROM pending_requests WHERE status = 'pending' ORDER BY created_at DESC`).all();
-  return rows;
-}
-function resolvePendingRequest(db, id, resolution) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const result = db.prepare(
-    `UPDATE pending_requests SET status = ?, resolved_at = ? WHERE id = ?`
-  ).run(resolution, now, id);
-  if (result.changes === 0) {
-    throw new AgentBnBError(
-      `Pending request not found: ${id}`,
-      "NOT_FOUND"
-    );
-  }
-}
-
 // src/autonomy/auto-request.ts
 function minMaxNormalize(values) {
   if (values.length === 0) return [];
@@ -154,11 +81,20 @@ function minMaxNormalize(values) {
 function scorePeers(candidates, selfOwner) {
   const eligible = candidates.filter((c) => c.card.owner !== selfOwner);
   if (eligible.length === 0) return [];
-  const successRates = eligible.map((c) => c.card.metadata?.success_rate ?? 0.5);
+  const successRates = eligible.map((c) => {
+    if (c.skillMetadata?.success_rate !== void 0) {
+      return c.skillMetadata.success_rate;
+    }
+    return c.card.metadata?.success_rate ?? 0.5;
+  });
   const costEfficiencies = eligible.map((c) => c.cost === 0 ? 1 : 1 / c.cost);
   const idleRates = eligible.map((c) => {
+    if (c.skillInternal !== void 0) {
+      const skillIdleRate = c.skillInternal["idle_rate"];
+      if (typeof skillIdleRate === "number") return skillIdleRate;
+    }
     const internal = c.card._internal;
-    const idleRate = internal?.idle_rate;
+    const idleRate = internal?.["idle_rate"];
     return typeof idleRate === "number" ? idleRate : 1;
   });
   const normSuccess = minMaxNormalize(successRates);
@@ -234,7 +170,14 @@ var AutoRequestor = class {
         for (const skill of cardAsV2.skills) {
           const cost = skill.pricing.credits_per_call;
           if (cost <= need.maxCostCredits) {
-            candidates.push({ card, cost, skillId: skill.id });
+            candidates.push({
+              card,
+              cost,
+              skillId: skill.id,
+              // Carry skill-level metadata so scorePeers() can prefer it over card-level
+              skillMetadata: skill.metadata,
+              skillInternal: skill._internal
+            });
           }
         }
       } else {
@@ -348,13 +291,8 @@ var AutoRequestor = class {
 };
 
 export {
-  DEFAULT_AUTONOMY_CONFIG,
-  getAutonomyTier,
-  insertAuditEvent,
   DEFAULT_BUDGET_CONFIG,
   BudgetManager,
-  listPendingRequests,
-  resolvePendingRequest,
   scorePeers,
   AutoRequestor
 };