agentbnb 2.2.0 → 3.1.0

package/dist/chunk-QVIGMCHA.js

@@ -0,0 +1,486 @@
+import {
+  findPeer
+} from "./chunk-BEI5MTNZ.js";
+import {
+  getBalance,
+  holdEscrow,
+  releaseEscrow,
+  settleEscrow
+} from "./chunk-ZJCIBK6O.js";
+import {
+  AgentBnBError
+} from "./chunk-TQMI73LL.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
+  );
+}
+
+// src/credit/budget.ts
+var DEFAULT_BUDGET_CONFIG = {
+  reserve_credits: 20
+};
+var BudgetManager = class {
+  /**
+   * Creates a new BudgetManager.
+   *
+   * @param creditDb - The credit SQLite database instance.
+   * @param owner - Agent owner identifier.
+   * @param config - Budget configuration. Defaults to DEFAULT_BUDGET_CONFIG (20 credit reserve).
+   */
+  constructor(creditDb, owner, config = DEFAULT_BUDGET_CONFIG) {
+    this.creditDb = creditDb;
+    this.owner = owner;
+    this.config = config;
+  }
+  /**
+   * Returns the number of credits available for spending.
+   * Computed as: max(0, balance - reserve_credits).
+   * Always returns a non-negative number — never goes below zero.
+   *
+   * @returns Available credits (balance minus reserve, floored at 0).
+   */
+  availableCredits() {
+    const balance = getBalance(this.creditDb, this.owner);
+    return Math.max(0, balance - this.config.reserve_credits);
+  }
+  /**
+   * Returns true if spending `amount` credits is permitted by budget rules.
+   *
+   * Rules:
+   * - Zero-cost calls (amount <= 0) always return true.
+   * - Any positive amount requires availableCredits() >= amount.
+   * - If balance is at or below the reserve floor, all positive-cost calls return false.
+   *
+   * @param amount - Number of credits to spend.
+   * @returns true if the spend is allowed, false if it would breach the reserve floor.
+   */
+  canSpend(amount) {
+    if (amount <= 0) return true;
+    return this.availableCredits() >= amount;
+  }
+};
+
+// 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));
+  if (filters.apis_used && filters.apis_used.length > 0) {
+    const requiredApis = filters.apis_used;
+    return results.filter((card) => {
+      const cardApis = card.metadata?.apis_used ?? [];
+      return requiredApis.every((api) => cardApis.includes(api));
+    });
+  }
+  return results;
+}
+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);
+  return rows.map((row) => JSON.parse(row.data));
+}
+
+// src/gateway/client.ts
+import { randomUUID as randomUUID2 } from "crypto";
+async function requestCapability(opts) {
+  const { gatewayUrl, token, cardId, params = {}, timeoutMs = 3e4, escrowReceipt } = opts;
+  const id = randomUUID2();
+  const payload = {
+    jsonrpc: "2.0",
+    id,
+    method: "capability.execute",
+    params: {
+      card_id: cardId,
+      ...params,
+      ...escrowReceipt ? { escrow_receipt: escrowReceipt } : {}
+    }
+  };
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(`${gatewayUrl}/rpc`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      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;
+}
+
+// src/autonomy/pending-requests.ts
+import { randomUUID as randomUUID3 } from "crypto";
+function createPendingRequest(db, opts) {
+  const id = randomUUID3();
+  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 [];
+  if (values.length === 1) return [1];
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  if (max === min) {
+    return values.map(() => 1);
+  }
+  return values.map((v) => (v - min) / (max - min));
+}
+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 costEfficiencies = eligible.map((c) => c.cost === 0 ? 1 : 1 / c.cost);
+  const idleRates = eligible.map((c) => {
+    const internal = c.card._internal;
+    const idleRate = internal?.idle_rate;
+    return typeof idleRate === "number" ? idleRate : 1;
+  });
+  const normSuccess = minMaxNormalize(successRates);
+  const normCost = minMaxNormalize(costEfficiencies);
+  const normIdle = minMaxNormalize(idleRates);
+  const scored = eligible.map((c, i) => ({
+    ...c,
+    rawScore: (normSuccess[i] ?? 0) * (normCost[i] ?? 0) * (normIdle[i] ?? 0)
+  }));
+  scored.sort((a, b) => b.rawScore - a.rawScore);
+  return scored;
+}
+var AutoRequestor = class {
+  owner;
+  registryDb;
+  creditDb;
+  autonomyConfig;
+  budgetManager;
+  /**
+   * Creates a new AutoRequestor.
+   *
+   * @param opts - Configuration for this AutoRequestor instance.
+   */
+  constructor(opts) {
+    this.owner = opts.owner;
+    this.registryDb = opts.registryDb;
+    this.creditDb = opts.creditDb;
+    this.autonomyConfig = opts.autonomyConfig;
+    this.budgetManager = opts.budgetManager;
+  }
+  /**
+   * Executes an autonomous capability request.
+   *
+   * Performs the full flow:
+   * 1. Search for matching capability cards
+   * 2. Filter self-owned and over-budget candidates
+   * 3. Score candidates using min-max normalized composite scoring
+   * 4. Resolve peer gateway config
+   * 5. Check autonomy tier (Tier 3 queues to pending_requests)
+   * 6. Check budget reserve
+   * 7. Hold escrow
+   * 8. Execute via peer gateway
+   * 9. Settle or release escrow based on outcome
+   * 10. Log audit event (for Tier 2 notifications and all failures)
+   *
+   * @param need - The capability need to fulfill.
+   * @returns The result of the auto-request attempt.
+   */
+  async requestWithAutonomy(need) {
+    const cards = searchCards(this.registryDb, need.query, { online: true });
+    const candidates = [];
+    for (const card of cards) {
+      const cardAsV2 = card;
+      if (Array.isArray(cardAsV2.skills)) {
+        for (const skill of cardAsV2.skills) {
+          const cost = skill.pricing.credits_per_call;
+          if (cost <= need.maxCostCredits) {
+            candidates.push({ card, cost, skillId: skill.id });
+          }
+        }
+      } else {
+        const cost = card.pricing.credits_per_call;
+        if (cost <= need.maxCostCredits) {
+          candidates.push({ card, cost, skillId: void 0 });
+        }
+      }
+    }
+    const scored = scorePeers(candidates, this.owner);
+    if (scored.length === 0) {
+      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);
+    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,
+        params: need.params
+      });
+      insertAuditEvent(this.registryDb, {
+        type: "auto_request_pending",
+        card_id: top.card.id,
+        skill_id: top.skillId ?? top.card.id,
+        tier_invoked: 3,
+        credits: top.cost,
+        peer: top.card.owner
+      });
+      return {
+        status: "tier_blocked",
+        reason: "Tier 3: owner approval required",
+        peer: top.card.owner
+      };
+    }
+    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");
+      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);
+    try {
+      const execResult = await requestCapability({
+        gatewayUrl: peerConfig.url,
+        token: peerConfig.token,
+        cardId: top.card.id,
+        params: top.skillId ? { skill_id: top.skillId, ...need.params } : need.params
+      });
+      settleEscrow(this.creditDb, escrowId, top.card.owner);
+      if (tier === 2) {
+        insertAuditEvent(this.registryDb, {
+          type: "auto_request_notify",
+          card_id: top.card.id,
+          skill_id: top.skillId ?? top.card.id,
+          tier_invoked: 2,
+          credits: top.cost,
+          peer: top.card.owner
+        });
+      } else {
+        insertAuditEvent(this.registryDb, {
+          type: "auto_request",
+          card_id: top.card.id,
+          skill_id: top.skillId ?? top.card.id,
+          tier_invoked: 1,
+          credits: top.cost,
+          peer: top.card.owner
+        });
+      }
+      return {
+        status: "success",
+        result: execResult,
+        escrowId,
+        peer: top.card.owner,
+        creditsSpent: top.cost
+      };
+    } 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}`);
+      return {
+        status: "failed",
+        reason: `Execution failed: ${reason}`,
+        peer: top.card.owner
+      };
+    }
+  }
+  /**
+   * Logs a failure audit event to request_log.
+   * Used for all non-success paths to satisfy REQ-06.
+   */
+  logFailure(type, cardId, skillId, tier, credits, peer, reason) {
+    insertAuditEvent(this.registryDb, {
+      type,
+      card_id: cardId,
+      skill_id: skillId,
+      tier_invoked: tier,
+      credits,
+      peer,
+      reason
+    });
+  }
+};
+
+// 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;
+}
+
+export {
+  DEFAULT_AUTONOMY_CONFIG,
+  getAutonomyTier,
+  insertAuditEvent,
+  DEFAULT_BUDGET_CONFIG,
+  BudgetManager,
+  searchCards,
+  filterCards,
+  requestCapability,
+  listPendingRequests,
+  resolvePendingRequest,
+  scorePeers,
+  AutoRequestor,
+  interpolateObject
+};