agentbnb 8.2.0 → 8.2.2

package/dist/{chunk-TBJ3FZKZ.js → chunk-4IPJJRTP.js}

@@ -1,6 +1,6 @@
 import {
   insertCard
-} from "./chunk-O2OYBAVR.js";
+} from "./chunk-S3V6R3EN.js";
 import {
   CapabilityCardSchema
 } from "./chunk-WVY2W7AA.js";

package/dist/chunk-CKOOVZOI.js

@@ -0,0 +1,158 @@
+import {
+  signEscrowReceipt
+} from "./chunk-EJKW57ZV.js";
+import {
+  AgentBnBError
+} from "./chunk-WVY2W7AA.js";
+
+// src/gateway/client.ts
+import { randomUUID } from "crypto";
+import { Agent } from "undici";
+var gatewayAgent = new Agent({
+  keepAliveTimeout: 3e4,
+  keepAliveMaxTimeout: 6e4,
+  connections: 10,
+  pipelining: 1
+});
+function buildGatewayAuthHeaders(payload, token, identity) {
+  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;
+  }
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  return headers;
+}
+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 = buildGatewayAuthHeaders(payload, token, identity);
+  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,
+      // undici dispatcher for connection pooling (Node.js 20+)
+      dispatcher: gatewayAgent
+    });
+  } 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 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 = buildGatewayAuthHeaders(batchPayload, token, identity);
+  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({
+      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");
+  }
+}
+
+export {
+  requestCapability,
+  requestCapabilityBatch,
+  requestViaRelay
+};

package/dist/chunk-CQFBNTGT.js

@@ -0,0 +1,145 @@
+import {
+  fetchRemoteCards,
+  searchCards
+} from "./chunk-RYISHSHB.js";
+import {
+  getCard
+} from "./chunk-S3V6R3EN.js";
+
+// 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 toResolved(card, queryOrId, source) {
+  const skill = pickSkill(card, queryOrId);
+  const gatewayUrl = getGatewayUrl(card);
+  const viaRelay = source === "local" ? false : gatewayUrl.length === 0;
+  const resolvedSource = viaRelay ? "relay" : source;
+  return {
+    cardId: card.id,
+    skillId: skill?.id,
+    owner: card.owner,
+    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 /^[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");
+    }
+    const bySkillId = findLocalBySkillId(registryDb, needle, onlineOnly);
+    if (bySkillId) {
+      return toResolved(bySkillId, needle, "local");
+    }
+    const localMatches = searchCards(registryDb, needle, { online: onlineOnly ? true : void 0 });
+    if (localMatches.length > 0) {
+      return toResolved(localMatches[0], needle, "local");
+    }
+  }
+  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");
+        }
+      }
+    } 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");
+      return toResolved(remoteMatches[0], needle, "remote");
+    }
+  } catch {
+  }
+  try {
+    const onlineCards = await fetchRemoteCards(registryUrl, {
+      ...onlineOnly ? { online: true } : {}
+    });
+    const exactSkill = findRemoteBySkillId(onlineCards, needle);
+    if (exactSkill) return toResolved(exactSkill, needle, "relay");
+    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");
+  } catch {
+  }
+  return null;
+}
+
+export {
+  resolveTargetCapability
+};