agentbnb 5.1.11 → 7.0.0-beta.1

package/dist/chunk-BP3L2TET.js

@@ -0,0 +1,148 @@
+import {
+  insertCard
+} from "./chunk-KA2VIEGM.js";
+import {
+  CapabilityCardSchema
+} from "./chunk-3CIMVISQ.js";
+
+// src/skills/publish-capability.ts
+import { randomUUID } from "crypto";
+function parseSoulMd(content) {
+  const lines = content.split("\n");
+  let name = "";
+  let description = "";
+  const capabilities = [];
+  const unknownSections = [];
+  let currentSection = null;
+  let currentCapabilityName = "";
+  let currentCapabilityLines = [];
+  let currentCapabilityPricing = void 0;
+  let descriptionLines = [];
+  let pastFirstH1 = false;
+  let pastFirstH2 = false;
+  const flushCapability = () => {
+    if (currentCapabilityName) {
+      const cap = {
+        name: currentCapabilityName,
+        description: currentCapabilityLines.join(" ").trim()
+      };
+      if (currentCapabilityPricing !== void 0) {
+        cap.pricing = currentCapabilityPricing;
+      }
+      capabilities.push(cap);
+      currentCapabilityName = "";
+      currentCapabilityLines = [];
+      currentCapabilityPricing = void 0;
+    }
+  };
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^# /.test(trimmed) && !pastFirstH1) {
+      name = trimmed.slice(2).trim();
+      pastFirstH1 = true;
+      currentSection = "preamble";
+      continue;
+    }
+    if (/^## /.test(trimmed)) {
+      flushCapability();
+      const capName = trimmed.slice(3).trim();
+      currentCapabilityName = capName;
+      currentSection = "capability";
+      pastFirstH2 = true;
+      continue;
+    }
+    if (/^#{3,} /.test(trimmed)) {
+      const sectionName = trimmed.replace(/^#+\s*/, "");
+      if (!unknownSections.includes(sectionName)) {
+        unknownSections.push(sectionName);
+      }
+      continue;
+    }
+    if (trimmed === "") continue;
+    if (currentSection === "preamble" && !pastFirstH2) {
+      descriptionLines.push(trimmed);
+    } else if (currentSection === "capability") {
+      const pricingMatch = trimmed.match(/^pricing:\s*(\d+(?:\.\d+)?)$/i);
+      if (pricingMatch) {
+        const val = parseFloat(pricingMatch[1]);
+        if (!isNaN(val) && val >= 0) {
+          currentCapabilityPricing = val;
+        }
+      } else {
+        currentCapabilityLines.push(trimmed);
+      }
+    }
+  }
+  flushCapability();
+  if (descriptionLines.length > 0) {
+    description = descriptionLines[0] ?? "";
+  }
+  return {
+    name,
+    description,
+    level: 2,
+    capabilities,
+    unknownSections
+  };
+}
+function publishFromSoul(db, soulContent, owner) {
+  const parsed = parseSoulMd(soulContent);
+  const capsSummary = parsed.capabilities.map((c) => c.name).join(", ");
+  const description = parsed.description.length > 0 ? parsed.description.slice(0, 500) : capsSummary.slice(0, 500);
+  const card = {
+    spec_version: "1.0",
+    id: randomUUID(),
+    owner,
+    name: parsed.name || "Unknown Agent",
+    description,
+    level: parsed.level,
+    inputs: [
+      {
+        name: "input",
+        type: "text",
+        description: "Input for the capability",
+        required: true
+      }
+    ],
+    outputs: [
+      {
+        name: "output",
+        type: "text",
+        description: "Output from the capability",
+        required: true
+      }
+    ],
+    pricing: {
+      credits_per_call: 10
+    },
+    availability: {
+      online: true
+    },
+    metadata: {
+      tags: parsed.capabilities.map((c) => c.name.toLowerCase().replace(/\s+/g, "-"))
+    }
+  };
+  CapabilityCardSchema.parse(card);
+  insertCard(db, card);
+  return card;
+}
+function skillConfigToSkill(config) {
+  return {
+    id: config.id,
+    name: config.name,
+    description: config.description ?? "",
+    level: 2,
+    inputs: [],
+    outputs: [],
+    pricing: config.pricing,
+    ...config.capability_types !== void 0 && { capability_types: config.capability_types },
+    ...config.requires_capabilities !== void 0 && { requires_capabilities: config.requires_capabilities },
+    ...config.visibility !== void 0 && { visibility: config.visibility }
+  };
+}
+
+export {
+  parseSoulMd,
+  publishFromSoul,
+  skillConfigToSkill
+};

package/dist/{chunk-NLAWT4DT.js → chunk-CWYPTQRQ.js}

@@ -1,16 +1,19 @@
 import {
   RelayClient
-} from "./chunk-JOY533UH.js";
+} from "./chunk-TW65F5EU.js";
 import {
   BudgetController,
   ORCHESTRATION_FEE,
   decompose,
   matchSubTasks,
   orchestrate
-} from "./chunk-WTXRY7R2.js";
+} from "./chunk-APEG4QIN.js";
 import {
   BudgetManager
-} from "./chunk-EGUOAHCW.js";
+} from "./chunk-GO4FVRVN.js";
+import {
+  openCreditDb
+} from "./chunk-J2K5S5MX.js";
 import {
   loadPeers
 } from "./chunk-5AH3CMOX.js";
@@ -19,10 +22,7 @@ import {
 } from "./chunk-75OC6E4F.js";
 import {
   openDatabase
-} from "./chunk-DFBX3BBD.js";
-import {
-  openCreditDb
-} from "./chunk-EANI2N2V.js";
+} from "./chunk-KA2VIEGM.js";
 
 // src/cli/conduct.ts
 async function conductAction(task, opts) {

package/dist/{chunk-UKT6H7YT.js → chunk-DUW6RX6I.js}

@@ -1,15 +1,18 @@
 import {
+  NETWORK_FEE_RATE,
   confirmEscrowDebit,
   recordEarning,
   releaseEscrow
-} from "./chunk-EANI2N2V.js";
+} from "./chunk-J2K5S5MX.js";
 
 // src/credit/settlement.ts
 function settleProviderEarning(providerDb, providerOwner, receipt) {
+  const feeAmount = Math.floor(receipt.amount * NETWORK_FEE_RATE);
+  const providerAmount = receipt.amount - feeAmount;
   recordEarning(
     providerDb,
     providerOwner,
-    receipt.amount,
+    providerAmount,
     receipt.card_id,
     receipt.nonce
   );

package/dist/chunk-EAD4A4KG.js

@@ -0,0 +1,430 @@
+import {
+  NETWORK_FEE_RATE,
+  confirmEscrowDebit,
+  getBalance,
+  getCard,
+  holdEscrow,
+  insertRequestLog,
+  recordEarning,
+  releaseEscrow,
+  settleEscrow,
+  updateReputation,
+  verifyEscrowReceipt
+} from "./chunk-K5FO42YF.js";
+import {
+  loadConfig
+} from "./chunk-IVOYM3WG.js";
+import {
+  AgentBnBError
+} from "./chunk-3CIMVISQ.js";
+
+// src/gateway/execute.ts
+import { randomUUID } from "crypto";
+
+// src/credit/settlement.ts
+function settleProviderEarning(providerDb, providerOwner, receipt) {
+  const feeAmount = Math.floor(receipt.amount * NETWORK_FEE_RATE);
+  const providerAmount = receipt.amount - feeAmount;
+  recordEarning(
+    providerDb,
+    providerOwner,
+    providerAmount,
+    receipt.card_id,
+    receipt.nonce
+  );
+  return { settled: true };
+}
+function settleRequesterEscrow(requesterDb, escrowId) {
+  confirmEscrowDebit(requesterDb, escrowId);
+}
+function releaseRequesterEscrow(requesterDb, escrowId) {
+  releaseEscrow(requesterDb, escrowId);
+}
+
+// src/gateway/execute.ts
+async function notifyTelegramSkillExecuted(opts) {
+  const cfg = loadConfig();
+  if (!cfg?.telegram_notifications) return;
+  const token = cfg.telegram_bot_token ?? process.env["TELEGRAM_BOT_TOKEN"];
+  const chatId = cfg.telegram_chat_id ?? process.env["TELEGRAM_CHAT_ID"];
+  if (!token || !chatId) return;
+  const balance = getBalance(opts.creditDb, opts.owner);
+  const skillLabel = opts.skillId ? `${opts.skillName} (${opts.skillId})` : opts.skillName;
+  const text = [
+    "[AgentBnB] Skill executed",
+    `Skill: ${skillLabel}`,
+    `Requester: ${opts.requester}`,
+    `Earned: +${opts.creditsEarned} credits`,
+    `Balance: ${balance} credits`,
+    `Latency: ${opts.latencyMs}ms`
+  ].join("\n");
+  await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ chat_id: chatId, text })
+  });
+}
+async function executeCapabilityRequest(opts) {
+  const {
+    registryDb,
+    creditDb,
+    cardId,
+    skillId,
+    params,
+    requester,
+    escrowReceipt: receipt,
+    skillExecutor,
+    handlerUrl,
+    timeoutMs = 3e5,
+    onProgress,
+    relayAuthorized = false
+  } = opts;
+  const card = getCard(registryDb, cardId);
+  if (!card) {
+    return { success: false, error: { code: -32602, message: `Card not found: ${cardId}` } };
+  }
+  if (requester === card.owner && !relayAuthorized) {
+    const msg = `Self-request blocked: requester (${requester}) is the card owner. Set AGENTBNB_DIR to your agent's config directory before calling agentbnb request.`;
+    try {
+      insertRequestLog(registryDb, {
+        id: randomUUID(),
+        card_id: cardId,
+        card_name: card.name,
+        skill_id: skillId,
+        requester,
+        status: "failure",
+        latency_ms: 0,
+        credits_charged: 0,
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        failure_reason: "auth_error"
+      });
+    } catch {
+    }
+    return { success: false, error: { code: -32603, message: msg } };
+  }
+  let creditsNeeded;
+  let cardName;
+  let resolvedSkillId;
+  const rawCard = card;
+  if (Array.isArray(rawCard["skills"])) {
+    const v2card = card;
+    const skill = skillId ? v2card.skills.find((s) => s.id === skillId) : v2card.skills[0];
+    if (!skill) {
+      return { success: false, error: { code: -32602, message: `Skill not found: ${skillId}` } };
+    }
+    creditsNeeded = skill.pricing.credits_per_call;
+    cardName = skill.name;
+    resolvedSkillId = skill.id;
+  } else {
+    creditsNeeded = card.pricing.credits_per_call;
+    cardName = card.name;
+  }
+  let escrowId = null;
+  let isRemoteEscrow = false;
+  if (relayAuthorized) {
+  } else if (receipt) {
+    const { signature, ...receiptData2 } = receipt;
+    const publicKeyBuf = Buffer.from(receipt.requester_public_key, "hex");
+    const valid = verifyEscrowReceipt(receiptData2, signature, publicKeyBuf);
+    if (!valid) {
+      return { success: false, error: { code: -32603, message: "Invalid escrow receipt signature" } };
+    }
+    if (receipt.amount < creditsNeeded) {
+      return { success: false, error: { code: -32603, message: "Insufficient escrow amount" } };
+    }
+    const receiptAge = Date.now() - new Date(receipt.timestamp).getTime();
+    if (receiptAge > 5 * 60 * 1e3) {
+      return { success: false, error: { code: -32603, message: "Escrow receipt expired" } };
+    }
+    isRemoteEscrow = true;
+  } else {
+    try {
+      const balance = getBalance(creditDb, requester);
+      if (balance < creditsNeeded) {
+        return { success: false, error: { code: -32603, message: "Insufficient credits" } };
+      }
+      escrowId = holdEscrow(creditDb, requester, creditsNeeded, cardId);
+    } catch (err) {
+      const msg = err instanceof AgentBnBError ? err.message : "Failed to hold escrow";
+      return { success: false, error: { code: -32603, message: msg } };
+    }
+  }
+  const startMs = Date.now();
+  const receiptData = isRemoteEscrow ? { receipt_released: true } : void 0;
+  const handleFailure = (status, latencyMs, message, failureReason = "bad_execution") => {
+    if (!isRemoteEscrow && escrowId) releaseEscrow(creditDb, escrowId);
+    if (failureReason === "bad_execution" || failureReason === "auth_error") {
+      updateReputation(registryDb, cardId, false, latencyMs);
+    }
+    try {
+      insertRequestLog(registryDb, {
+        id: randomUUID(),
+        card_id: cardId,
+        card_name: cardName,
+        skill_id: resolvedSkillId,
+        requester,
+        status,
+        latency_ms: latencyMs,
+        credits_charged: 0,
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        failure_reason: failureReason
+      });
+    } catch {
+    }
+    return {
+      success: false,
+      error: { code: -32603, message, ...receiptData ? { data: receiptData } : {} }
+    };
+  };
+  const handleSuccess = (result, latencyMs) => {
+    if (isRemoteEscrow && receipt) {
+      settleProviderEarning(creditDb, card.owner, receipt);
+    } else if (escrowId) {
+      settleEscrow(creditDb, escrowId, card.owner);
+    }
+    updateReputation(registryDb, cardId, true, latencyMs);
+    try {
+      insertRequestLog(registryDb, {
+        id: randomUUID(),
+        card_id: cardId,
+        card_name: cardName,
+        skill_id: resolvedSkillId,
+        requester,
+        status: "success",
+        latency_ms: latencyMs,
+        credits_charged: creditsNeeded,
+        created_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } catch {
+    }
+    notifyTelegramSkillExecuted({
+      creditDb,
+      owner: card.owner,
+      skillName: cardName,
+      skillId: resolvedSkillId ?? null,
+      requester,
+      creditsEarned: creditsNeeded,
+      latencyMs
+    }).catch(() => {
+    });
+    const successResult = isRemoteEscrow ? {
+      ...typeof result === "object" && result !== null ? result : { data: result },
+      receipt_settled: true,
+      receipt_nonce: receipt.nonce
+    } : result;
+    return { success: true, result: successResult };
+  };
+  if (skillExecutor) {
+    let targetSkillId = resolvedSkillId ?? skillId;
+    if (!targetSkillId) {
+      const available = skillExecutor.listSkills();
+      if (available.length > 0) {
+        targetSkillId = available[0];
+      } else {
+        return handleFailure(
+          "failure",
+          Date.now() - startMs,
+          "No skill_id specified and no skills registered on this provider.",
+          "not_found"
+        );
+      }
+    }
+    try {
+      const execResult = await skillExecutor.execute(targetSkillId, params, onProgress);
+      if (!execResult.success) {
+        return handleFailure("failure", execResult.latency_ms, execResult.error ?? "Execution failed", "bad_execution");
+      }
+      return handleSuccess(execResult.result, execResult.latency_ms);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Execution error";
+      return handleFailure("failure", Date.now() - startMs, message, "bad_execution");
+    }
+  }
+  if (!handlerUrl) {
+    return handleFailure("failure", Date.now() - startMs, "No skill executor or handler URL configured", "bad_execution");
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(handlerUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ card_id: cardId, skill_id: resolvedSkillId, params }),
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    if (!response.ok) {
+      return handleFailure("failure", Date.now() - startMs, `Handler returned ${response.status}`, "bad_execution");
+    }
+    const result = await response.json();
+    return handleSuccess(result, Date.now() - startMs);
+  } catch (err) {
+    clearTimeout(timer);
+    const isTimeout = err instanceof Error && err.name === "AbortError";
+    return handleFailure(
+      isTimeout ? "timeout" : "failure",
+      Date.now() - startMs,
+      isTimeout ? "Execution timeout" : "Handler error",
+      isTimeout ? "timeout" : "bad_execution"
+    );
+  }
+}
+async function executeCapabilityBatch(options) {
+  const { requests, strategy, total_budget, registryDb, creditDb, owner } = options;
+  if (requests.length === 0) {
+    return { results: [], total_credits_spent: 0, total_credits_refunded: 0, success: true };
+  }
+  const sumMaxCredits = requests.reduce((acc, r) => acc + r.max_credits, 0);
+  if (sumMaxCredits > total_budget) {
+    return {
+      results: requests.map((_, i) => ({
+        request_index: i,
+        status: "skipped",
+        credits_spent: 0,
+        credits_refunded: 0,
+        error: `Total requested credits (${sumMaxCredits}) exceeds total_budget (${total_budget})`
+      })),
+      total_credits_spent: 0,
+      total_credits_refunded: 0,
+      success: false
+    };
+  }
+  const executeItem = async (item, index) => {
+    const card = getCard(registryDb, item.skill_id);
+    if (!card) {
+      return {
+        request_index: index,
+        status: "failed",
+        credits_spent: 0,
+        credits_refunded: 0,
+        error: `Card/skill not found: ${item.skill_id}`
+      };
+    }
+    const rawCard = card;
+    let creditsNeeded;
+    let resolvedSkillId;
+    if (Array.isArray(rawCard["skills"])) {
+      const v2card = card;
+      const skill = v2card.skills[0];
+      if (!skill) {
+        return {
+          request_index: index,
+          status: "failed",
+          credits_spent: 0,
+          credits_refunded: 0,
+          error: `No skills defined on card: ${item.skill_id}`
+        };
+      }
+      creditsNeeded = skill.pricing.credits_per_call;
+      resolvedSkillId = skill.id;
+    } else {
+      creditsNeeded = card.pricing.credits_per_call;
+    }
+    if (creditsNeeded > item.max_credits) {
+      return {
+        request_index: index,
+        status: "failed",
+        credits_spent: 0,
+        credits_refunded: 0,
+        error: `Skill costs ${creditsNeeded} credits but max_credits is ${item.max_credits}`
+      };
+    }
+    let escrowId;
+    try {
+      const balance = getBalance(creditDb, owner);
+      if (balance < creditsNeeded) {
+        return {
+          request_index: index,
+          status: "failed",
+          credits_spent: 0,
+          credits_refunded: 0,
+          error: "Insufficient credits"
+        };
+      }
+      escrowId = holdEscrow(creditDb, owner, creditsNeeded, card.id);
+    } catch (err) {
+      const msg = err instanceof AgentBnBError ? err.message : "Failed to hold escrow";
+      return {
+        request_index: index,
+        status: "failed",
+        credits_spent: 0,
+        credits_refunded: 0,
+        error: msg
+      };
+    }
+    const startMs = Date.now();
+    const latencyMs = Date.now() - startMs;
+    settleEscrow(creditDb, escrowId, card.owner);
+    updateReputation(registryDb, card.id, true, latencyMs);
+    try {
+      insertRequestLog(registryDb, {
+        id: randomUUID(),
+        card_id: card.id,
+        card_name: card.name,
+        skill_id: resolvedSkillId,
+        requester: owner,
+        status: "success",
+        latency_ms: latencyMs,
+        credits_charged: creditsNeeded,
+        created_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } catch {
+    }
+    return {
+      request_index: index,
+      status: "success",
+      result: { card_id: card.id, skill_id: resolvedSkillId },
+      credits_spent: creditsNeeded,
+      credits_refunded: 0
+    };
+  };
+  let results;
+  if (strategy === "sequential") {
+    results = [];
+    let stopped = false;
+    for (let i = 0; i < requests.length; i++) {
+      if (stopped) {
+        results.push({
+          request_index: i,
+          status: "skipped",
+          credits_spent: 0,
+          credits_refunded: 0,
+          error: "Skipped due to earlier failure"
+        });
+        continue;
+      }
+      const result = await executeItem(requests[i], i);
+      results.push(result);
+      if (result.status === "failed") {
+        stopped = true;
+      }
+    }
+  } else {
+    const settled = await Promise.allSettled(
+      requests.map((item, i) => executeItem(item, i))
+    );
+    results = settled.map((outcome, i) => {
+      if (outcome.status === "fulfilled") {
+        return outcome.value;
+      }
+      return {
+        request_index: i,
+        status: "failed",
+        credits_spent: 0,
+        credits_refunded: 0,
+        error: outcome.reason instanceof Error ? outcome.reason.message : "Unknown error"
+      };
+    });
+  }
+  const total_credits_spent = results.reduce((acc, r) => acc + r.credits_spent, 0);
+  const total_credits_refunded = results.reduce((acc, r) => acc + r.credits_refunded, 0);
+  const success = results.every((r) => r.status === "success");
+  return { results, total_credits_spent, total_credits_refunded, success };
+}
+
+export {
+  settleRequesterEscrow,
+  releaseRequesterEscrow,
+  executeCapabilityRequest,
+  executeCapabilityBatch
+};

package/dist/{chunk-QT7TEVNV.js → chunk-EHSHB7TY.js}

@@ -66,6 +66,27 @@ var RelayProgressMessageSchema = z.object({
   message: z.string().optional()
   // optional status message
 });
+var HeartbeatMessageSchema = z.object({
+  type: z.literal("heartbeat"),
+  owner: z.string().min(1),
+  capacity: z.object({
+    current_load: z.number(),
+    max_concurrent: z.number(),
+    queue_depth: z.number()
+  }),
+  self_summary: z.object({
+    capabilities: z.array(z.string()),
+    success_rate: z.number(),
+    credit_balance: z.number(),
+    total_completed: z.number(),
+    provider_number: z.number(),
+    reliability: z.object({
+      current_streak: z.number(),
+      repeat_hire_rate: z.number(),
+      avg_feedback: z.number()
+    })
+  })
+});
 var RelayMessageSchema = z.discriminatedUnion("type", [
   RegisterMessageSchema,
   RegisteredMessageSchema,
@@ -74,7 +95,8 @@ var RelayMessageSchema = z.discriminatedUnion("type", [
   RelayResponseMessageSchema,
   ResponseMessageSchema,
   ErrorMessageSchema,
-  RelayProgressMessageSchema
+  RelayProgressMessageSchema,
+  HeartbeatMessageSchema
 ]);
 
 export {