agentbnb 8.2.2 → 8.3.0

package/dist/chunk-NQANA6WH.js

@@ -0,0 +1,797 @@
+import {
+  canonicalizeCreditOwner,
+  ensureReliabilityTable,
+  migrateCreditOwnerData,
+  recordSuccessfulHire
+} from "./chunk-6QMDJVMS.js";
+import {
+  getCard,
+  getFeedbackForProvider
+} from "./chunk-ZU2TP7CN.js";
+import {
+  ensureAgentsTable,
+  resolveCanonicalIdentity
+} from "./chunk-EE3V3DXK.js";
+import {
+  AgentBnBError
+} from "./chunk-I7KWA7OB.js";
+
+// src/credit/ledger.ts
+import Database from "better-sqlite3";
+import { randomUUID } from "crypto";
+var CREDIT_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS credit_balances (
+    owner TEXT PRIMARY KEY,
+    balance INTEGER NOT NULL DEFAULT 0,
+    updated_at TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS credit_transactions (
+    id TEXT PRIMARY KEY,
+    owner TEXT NOT NULL,
+    amount INTEGER NOT NULL,
+    reason TEXT NOT NULL,
+    reference_id TEXT,
+    created_at TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS credit_escrow (
+    id TEXT PRIMARY KEY,
+    owner TEXT NOT NULL,
+    amount INTEGER NOT NULL,
+    card_id TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'held',
+    created_at TEXT NOT NULL,
+    settled_at TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS provider_registry (
+    owner TEXT PRIMARY KEY,
+    provider_number INTEGER NOT NULL,
+    registered_at TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS demand_vouchers (
+    id TEXT PRIMARY KEY,
+    owner TEXT NOT NULL,
+    amount INTEGER NOT NULL,
+    remaining INTEGER NOT NULL,
+    created_at TEXT NOT NULL,
+    expires_at TEXT NOT NULL,
+    is_active INTEGER NOT NULL DEFAULT 1
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_transactions_owner ON credit_transactions(owner, created_at);
+  CREATE INDEX IF NOT EXISTS idx_escrow_owner ON credit_escrow(owner);
+`;
+function openCreditDb(path = ":memory:") {
+  const db = new Database(path);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(CREDIT_SCHEMA);
+  try {
+    db.exec("ALTER TABLE credit_escrow ADD COLUMN funding_source TEXT NOT NULL DEFAULT 'balance'");
+  } catch {
+  }
+  ensureReliabilityTable(db);
+  ensureAgentsTable(db);
+  return db;
+}
+function bootstrapAgent(db, owner, amount = 100) {
+  const canonicalOwner = canonicalizeCreditOwner(db, owner);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let isNew = false;
+  db.transaction(() => {
+    const result = db.prepare("INSERT OR IGNORE INTO credit_balances (owner, balance, updated_at) VALUES (?, ?, ?)").run(canonicalOwner, amount, now);
+    if (result.changes > 0) {
+      isNew = true;
+      db.prepare(
+        "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+      ).run(randomUUID(), canonicalOwner, amount, "bootstrap", null, now);
+    }
+  })();
+  if (isNew) {
+    issueVoucher(db, canonicalOwner, 50, 30);
+  }
+}
+function getBalance(db, owner) {
+  const canonicalOwner = canonicalizeCreditOwner(db, owner);
+  const row = db.prepare("SELECT balance FROM credit_balances WHERE owner = ?").get(canonicalOwner);
+  return row?.balance ?? 0;
+}
+function getTransactions(db, owner, opts = 100) {
+  const canonicalOwner = canonicalizeCreditOwner(db, owner);
+  const page = typeof opts === "number" ? { limit: opts } : opts;
+  const limit = page.limit ?? 100;
+  const conditions = ["owner = ?"];
+  const params = [canonicalOwner];
+  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 ${conditions.join(" AND ")} ORDER BY created_at DESC LIMIT ?`
+  ).all(...params);
+}
+function registerProvider(db, owner) {
+  const canonicalOwner = canonicalizeCreditOwner(db, owner);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const maxRow = db.prepare("SELECT MAX(provider_number) as maxNum FROM provider_registry").get();
+  const nextNum = (maxRow?.maxNum ?? 0) + 1;
+  db.prepare("INSERT OR IGNORE INTO provider_registry (owner, provider_number, registered_at) VALUES (?, ?, ?)").run(canonicalOwner, nextNum, now);
+  const row = db.prepare("SELECT provider_number FROM provider_registry WHERE owner = ?").get(canonicalOwner);
+  return row.provider_number;
+}
+function getProviderNumber(db, owner) {
+  const canonicalOwner = canonicalizeCreditOwner(db, owner);
+  const row = db.prepare("SELECT provider_number FROM provider_registry WHERE owner = ?").get(canonicalOwner);
+  return row?.provider_number ?? null;
+}
+function getProviderBonus(providerNumber) {
+  if (providerNumber <= 50) return 2;
+  if (providerNumber <= 200) return 1.5;
+  return 1;
+}
+function issueVoucher(db, owner, amount = 50, daysValid = 30) {
+  const canonicalOwner = canonicalizeCreditOwner(db, owner);
+  const id = randomUUID();
+  const now = /* @__PURE__ */ new Date();
+  const expiresAt = new Date(now.getTime() + daysValid * 24 * 60 * 60 * 1e3);
+  db.prepare(
+    "INSERT INTO demand_vouchers (id, owner, amount, remaining, created_at, expires_at, is_active) VALUES (?, ?, ?, ?, ?, ?, 1)"
+  ).run(id, canonicalOwner, amount, amount, now.toISOString(), expiresAt.toISOString());
+  return id;
+}
+function getActiveVoucher(db, owner) {
+  const canonicalOwner = canonicalizeCreditOwner(db, owner);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const row = db.prepare(
+    "SELECT id, remaining, expires_at FROM demand_vouchers WHERE owner = ? AND is_active = 1 AND remaining > 0 AND expires_at > ? ORDER BY created_at ASC LIMIT 1"
+  ).get(canonicalOwner, now);
+  return row ?? null;
+}
+function consumeVoucher(db, voucherId, amount) {
+  db.prepare(
+    "UPDATE demand_vouchers SET remaining = remaining - ? WHERE id = ? AND remaining >= ?"
+  ).run(amount, voucherId, amount);
+}
+function migrateOwner(db, oldOwner, newOwner) {
+  if (oldOwner === newOwner) return;
+  const canonicalNewOwner = canonicalizeCreditOwner(db, newOwner);
+  migrateCreditOwnerData(db, oldOwner, canonicalNewOwner);
+}
+
+// src/credit/escrow.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var NETWORK_FEE_RATE = 0.05;
+var FINALIZABLE_ESCROW_STATUSES = /* @__PURE__ */ new Set([
+  "held",
+  "started",
+  "progressing",
+  "abandoned"
+]);
+var TERMINAL_ESCROW_STATUSES = /* @__PURE__ */ new Set(["settled", "released"]);
+function getEscrowForMutation(db, escrowId) {
+  const escrow = db.prepare("SELECT id, owner, amount, status, funding_source FROM credit_escrow WHERE id = ?").get(escrowId);
+  if (!escrow) {
+    throw new AgentBnBError(`Escrow not found: ${escrowId}`, "ESCROW_NOT_FOUND");
+  }
+  return {
+    ...escrow,
+    owner: canonicalizeCreditOwner(db, escrow.owner)
+  };
+}
+function updateEscrowStatus(db, escrowId, fromStatuses, toStatus) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const transition = db.transaction(() => {
+    const escrow = getEscrowForMutation(db, escrowId);
+    const current = escrow.status;
+    if (!fromStatuses.includes(current)) {
+      throw new AgentBnBError(
+        `Invalid escrow transition for ${escrowId}: ${current} -> ${toStatus}`,
+        "ESCROW_INVALID_TRANSITION"
+      );
+    }
+    if (current === toStatus) return;
+    const settledAt = TERMINAL_ESCROW_STATUSES.has(toStatus) ? now : null;
+    db.prepare("UPDATE credit_escrow SET status = ?, settled_at = ? WHERE id = ?").run(
+      toStatus,
+      settledAt,
+      escrowId
+    );
+  });
+  transition();
+}
+function assertEscrowCanFinalize(escrow) {
+  const status = escrow.status;
+  if (FINALIZABLE_ESCROW_STATUSES.has(status)) {
+    return;
+  }
+  if (TERMINAL_ESCROW_STATUSES.has(status)) {
+    throw new AgentBnBError(
+      `Escrow ${escrow.id} is already ${status}`,
+      "ESCROW_ALREADY_SETTLED"
+    );
+  }
+  throw new AgentBnBError(
+    `Escrow ${escrow.id} has invalid lifecycle status: ${escrow.status}`,
+    "ESCROW_INVALID_TRANSITION"
+  );
+}
+function holdEscrow(db, owner, amount, cardId) {
+  const canonicalOwner = canonicalizeCreditOwner(db, owner);
+  const escrowId = randomUUID2();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const hold = db.transaction(() => {
+    const voucher = getActiveVoucher(db, canonicalOwner);
+    if (voucher && voucher.remaining >= amount) {
+      consumeVoucher(db, voucher.id, amount);
+      db.prepare(
+        "INSERT INTO credit_escrow (id, owner, amount, card_id, status, created_at, funding_source) VALUES (?, ?, ?, ?, ?, ?, ?)"
+      ).run(escrowId, canonicalOwner, amount, cardId, "held", now, "voucher");
+      db.prepare(
+        "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+      ).run(randomUUID2(), canonicalOwner, -amount, "voucher_hold", escrowId, now);
+    } else {
+      const row = db.prepare("SELECT balance FROM credit_balances WHERE owner = ?").get(canonicalOwner);
+      if (!row || row.balance < amount) {
+        throw new AgentBnBError("Insufficient credits", "INSUFFICIENT_CREDITS");
+      }
+      db.prepare(
+        "UPDATE credit_balances SET balance = balance - ?, updated_at = ? WHERE owner = ? AND balance >= ?"
+      ).run(amount, now, canonicalOwner, amount);
+      db.prepare(
+        "INSERT INTO credit_escrow (id, owner, amount, card_id, status, created_at, funding_source) VALUES (?, ?, ?, ?, ?, ?, ?)"
+      ).run(escrowId, canonicalOwner, amount, cardId, "held", now, "balance");
+      db.prepare(
+        "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+      ).run(randomUUID2(), canonicalOwner, -amount, "escrow_hold", escrowId, now);
+    }
+  });
+  hold();
+  return escrowId;
+}
+function markEscrowStarted(db, escrowId) {
+  updateEscrowStatus(db, escrowId, ["held", "started"], "started");
+}
+function markEscrowProgressing(db, escrowId) {
+  updateEscrowStatus(db, escrowId, ["held", "started", "progressing"], "progressing");
+}
+function markEscrowAbandoned(db, escrowId) {
+  updateEscrowStatus(db, escrowId, ["started", "progressing", "abandoned"], "abandoned");
+}
+function settleEscrow(db, escrowId, recipientOwner) {
+  const canonicalRecipientOwner = canonicalizeCreditOwner(db, recipientOwner);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const settle = db.transaction(() => {
+    const escrow = getEscrowForMutation(db, escrowId);
+    assertEscrowCanFinalize(escrow);
+    const feeAmount = Math.floor(escrow.amount * NETWORK_FEE_RATE);
+    const providerAmount = escrow.amount - feeAmount;
+    db.prepare(
+      "INSERT OR IGNORE INTO credit_balances (owner, balance, updated_at) VALUES (?, 0, ?)"
+    ).run(canonicalRecipientOwner, now);
+    db.prepare(
+      "UPDATE credit_balances SET balance = balance + ?, updated_at = ? WHERE owner = ?"
+    ).run(providerAmount, now, canonicalRecipientOwner);
+    if (feeAmount > 0) {
+      db.prepare(
+        "INSERT OR IGNORE INTO credit_balances (owner, balance, updated_at) VALUES (?, 0, ?)"
+      ).run("platform_treasury", now);
+      db.prepare(
+        "UPDATE credit_balances SET balance = balance + ?, updated_at = ? WHERE owner = ?"
+      ).run(feeAmount, now, "platform_treasury");
+      db.prepare(
+        "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+      ).run(randomUUID2(), "platform_treasury", feeAmount, "network_fee", escrowId, now);
+    }
+    db.prepare(
+      "UPDATE credit_escrow SET status = ?, settled_at = ? WHERE id = ?"
+    ).run("settled", now, escrowId);
+    db.prepare(
+      "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+    ).run(randomUUID2(), canonicalRecipientOwner, providerAmount, "settlement", escrowId, now);
+    let providerNum = getProviderNumber(db, canonicalRecipientOwner);
+    if (providerNum === null) {
+      providerNum = registerProvider(db, canonicalRecipientOwner);
+    }
+    const bonus = getProviderBonus(providerNum);
+    if (bonus > 1) {
+      const bonusAmount = Math.floor(providerAmount * (bonus - 1));
+      if (bonusAmount > 0) {
+        db.prepare(
+          "INSERT OR IGNORE INTO credit_balances (owner, balance, updated_at) VALUES (?, 0, ?)"
+        ).run("platform_treasury", now);
+        db.prepare(
+          "UPDATE credit_balances SET balance = balance + ?, updated_at = ? WHERE owner = ?"
+        ).run(bonusAmount, now, canonicalRecipientOwner);
+        db.prepare(
+          "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+        ).run(randomUUID2(), canonicalRecipientOwner, bonusAmount, "provider_bonus", escrowId, now);
+      }
+    }
+    try {
+      recordSuccessfulHire(db, canonicalRecipientOwner, escrow.owner);
+    } catch {
+    }
+  });
+  settle();
+}
+function releaseEscrow(db, escrowId) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const release = db.transaction(() => {
+    const escrow = getEscrowForMutation(db, escrowId);
+    assertEscrowCanFinalize(escrow);
+    db.prepare(
+      "UPDATE credit_balances SET balance = balance + ?, updated_at = ? WHERE owner = ?"
+    ).run(escrow.amount, now, escrow.owner);
+    db.prepare(
+      "UPDATE credit_escrow SET status = ?, settled_at = ? WHERE id = ?"
+    ).run("released", now, escrowId);
+    db.prepare(
+      "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+    ).run(randomUUID2(), escrow.owner, escrow.amount, "refund", escrowId, now);
+  });
+  release();
+}
+function confirmEscrowDebit(db, escrowId) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const confirm = db.transaction(() => {
+    const escrow = getEscrowForMutation(db, escrowId);
+    assertEscrowCanFinalize(escrow);
+    db.prepare(
+      "UPDATE credit_escrow SET status = ?, settled_at = ? WHERE id = ?"
+    ).run("settled", now, escrowId);
+    db.prepare(
+      "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+    ).run(randomUUID2(), escrow.owner, 0, "remote_settlement_confirmed", escrowId, now);
+  });
+  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;
+}
+
+// src/gateway/resolve-target-capability.ts
+function canQueryLocalDb(db) {
+  return Boolean(db) && typeof db.prepare === "function";
+}
+function getGatewayUrl(card) {
+  if (typeof card.gateway_url === "string" && card.gateway_url.length > 0) {
+    return card.gateway_url;
+  }
+  const internal = card._internal;
+  const internalGateway = internal?.["gateway_url"];
+  return typeof internalGateway === "string" ? internalGateway : "";
+}
+function isOnline(card) {
+  return card.availability?.online !== false;
+}
+function scoreSkill(skill, query) {
+  const q = query.toLowerCase();
+  if (skill.id.toLowerCase() === q) return 100;
+  let score = 0;
+  if (skill.id.toLowerCase().includes(q)) score += 40;
+  if (skill.name.toLowerCase().includes(q)) score += 20;
+  if (skill.description.toLowerCase().includes(q)) score += 10;
+  return score;
+}
+function pickSkill(card, queryOrId) {
+  const skills = Array.isArray(card.skills) ? card.skills : [];
+  if (skills.length === 0) return void 0;
+  const exact = skills.find((s) => s.id === queryOrId);
+  if (exact) return exact;
+  const scored = skills.map((skill) => ({ skill, score: scoreSkill(skill, queryOrId) })).sort((a, b) => b.score - a.score);
+  if ((scored[0]?.score ?? 0) > 0) return scored[0]?.skill;
+  return skills[0];
+}
+function resolveCardAgentId(card, registryDb) {
+  if (typeof card.agent_id === "string" && card.agent_id.length > 0) {
+    return card.agent_id;
+  }
+  if (!canQueryLocalDb(registryDb)) return void 0;
+  const resolved = resolveCanonicalIdentity(registryDb, card.owner);
+  return resolved.resolved ? resolved.agent_id : void 0;
+}
+function toResolved(card, queryOrId, source, registryDb) {
+  const skill = pickSkill(card, queryOrId);
+  const gatewayUrl = getGatewayUrl(card);
+  const viaRelay = source === "local" ? false : gatewayUrl.length === 0;
+  const resolvedSource = viaRelay ? "relay" : source;
+  const agentId = resolveCardAgentId(card, registryDb);
+  return {
+    cardId: card.id,
+    skillId: skill?.id,
+    owner: card.owner,
+    ...agentId ? { agent_id: agentId } : {},
+    gateway_url: gatewayUrl,
+    via_relay: viaRelay,
+    credits_per_call: skill?.pricing.credits_per_call ?? card.pricing.credits_per_call,
+    source: resolvedSource
+  };
+}
+function findLocalBySkillId(db, skillId, onlineOnly) {
+  const rows = db.prepare("SELECT data FROM capability_cards").all();
+  for (const row of rows) {
+    const card = JSON.parse(row.data);
+    if (onlineOnly && !isOnline(card)) continue;
+    const skills = Array.isArray(card.skills) ? card.skills : [];
+    if (skills.some((s) => s.id === skillId)) {
+      return card;
+    }
+  }
+  return null;
+}
+function findRemoteBySkillId(cards, skillId) {
+  for (const card of cards) {
+    const skills = Array.isArray(card.skills) ? card.skills : [];
+    if (skills.some((s) => s.id === skillId)) return card;
+  }
+  return null;
+}
+function looksLikeCardId(value) {
+  return value.startsWith("card-") || /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
+async function resolveTargetCapability(queryOrId, options) {
+  const { registryDb, registryUrl, onlineOnly = true } = options;
+  const needle = queryOrId.trim();
+  if (needle.length === 0) return null;
+  if (canQueryLocalDb(registryDb)) {
+    const byCardId = getCard(registryDb, needle);
+    if (byCardId && (!onlineOnly || isOnline(byCardId))) {
+      return toResolved(byCardId, needle, "local", registryDb);
+    }
+    const bySkillId = findLocalBySkillId(registryDb, needle, onlineOnly);
+    if (bySkillId) {
+      return toResolved(bySkillId, needle, "local", registryDb);
+    }
+    const localMatches = searchCards(registryDb, needle, { online: onlineOnly ? true : void 0 });
+    if (localMatches.length > 0) {
+      return toResolved(localMatches[0], needle, "local", registryDb);
+    }
+  }
+  if (!registryUrl) return null;
+  if (looksLikeCardId(needle)) {
+    try {
+      const cardResp = await fetch(`${registryUrl.replace(/\/$/, "")}/cards/${encodeURIComponent(needle)}`);
+      if (cardResp.ok) {
+        const remoteCard = await cardResp.json();
+        if (!onlineOnly || isOnline(remoteCard)) {
+          return toResolved(remoteCard, needle, "remote", registryDb);
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    const remoteMatches = await fetchRemoteCards(registryUrl, {
+      q: needle,
+      ...onlineOnly ? { online: true } : {}
+    });
+    if (remoteMatches.length > 0) {
+      const exactSkill = findRemoteBySkillId(remoteMatches, needle);
+      if (exactSkill) return toResolved(exactSkill, needle, "remote", registryDb);
+      return toResolved(remoteMatches[0], needle, "remote", registryDb);
+    }
+  } catch {
+  }
+  try {
+    const onlineCards = await fetchRemoteCards(registryUrl, {
+      ...onlineOnly ? { online: true } : {}
+    });
+    const exactSkill = findRemoteBySkillId(onlineCards, needle);
+    if (exactSkill) return toResolved(exactSkill, needle, "relay", registryDb);
+    const tokens = needle.toLowerCase().split(/\s+/).filter((t) => t.length > 0);
+    const fuzzy = onlineCards.find((card) => {
+      const text = [
+        card.name,
+        card.description,
+        ...Array.isArray(card.skills) ? card.skills.map((s) => `${s.id} ${s.name} ${s.description}`) : []
+      ].join(" ").toLowerCase();
+      return tokens.some((token) => text.includes(token));
+    });
+    if (fuzzy) return toResolved(fuzzy, needle, "relay", registryDb);
+  } catch {
+  }
+  return null;
+}
+
+export {
+  openCreditDb,
+  bootstrapAgent,
+  getBalance,
+  getTransactions,
+  migrateOwner,
+  holdEscrow,
+  markEscrowStarted,
+  markEscrowProgressing,
+  markEscrowAbandoned,
+  settleEscrow,
+  releaseEscrow,
+  confirmEscrowDebit,
+  computeReputation,
+  searchCards,
+  filterCards,
+  buildReputationMap,
+  fetchRemoteCards,
+  mergeResults,
+  resolveTargetCapability
+};