agentbnb 8.2.3 → 8.3.1

package/dist/{chunk-Z4MCGKTL.js → chunk-NX27AFPA.js}

@@ -1,6 +1,6 @@
 import {
   RelayMessageSchema
-} from "./chunk-SSK653A6.js";
+} from "./chunk-PQIP7EXY.js";
 
 // src/relay/websocket-client.ts
 import WebSocket from "ws";
@@ -125,10 +125,23 @@ var RelayClient = class {
       });
     });
   }
+  /**
+   * Send a relay_started message to acknowledge that provider has started work.
+   *
+   * @param requestId - The relay request ID being processed.
+   * @param message - Optional status message.
+   */
+  sendStarted(requestId, message) {
+    this.send({
+      type: "relay_started",
+      id: requestId,
+      ...message ? { message } : {}
+    });
+  }
   /**
    * Send a relay_progress message to the relay server for a given request.
    * Used by the onRequest handler to forward SkillExecutor progress updates
-   * to the requesting agent so it can reset its timeout window.
+   * to the requesting agent while work is in-flight.
    *
    * @param requestId - The relay request ID to associate progress with.
    * @param info - Progress details (step, total, message).

package/dist/{chunk-Z2GEFFDO.js → chunk-O4Q7BRG6.js}

@@ -1,9 +1,9 @@
 import {
   searchCards
-} from "./chunk-RYISHSHB.js";
+} from "./chunk-F3KIEVJ2.js";
 import {
   AgentBnBError
-} from "./chunk-WVY2W7AA.js";
+} from "./chunk-I7KWA7OB.js";
 
 // src/registry/pricing.ts
 function getPricingStats(db, query) {

package/dist/{chunk-SSK653A6.js → chunk-PQIP7EXY.js}

@@ -79,6 +79,11 @@ var RelayProgressMessageSchema = z.object({
   message: z.string().optional()
   // optional status message
 });
+var RelayStartedMessageSchema = z.object({
+  type: z.literal("relay_started"),
+  id: z.string().uuid(),
+  message: z.string().optional()
+});
 var HeartbeatMessageSchema = z.object({
   type: z.literal("heartbeat"),
   owner: z.string().min(1),
@@ -155,6 +160,7 @@ var RelayMessageSchema = z.discriminatedUnion("type", [
   ResponseMessageSchema,
   ErrorMessageSchema,
   RelayProgressMessageSchema,
+  RelayStartedMessageSchema,
   HeartbeatMessageSchema,
   EscrowHoldMessageSchema,
   EscrowHoldConfirmedMessageSchema,

package/dist/{chunk-EG6RS4JC.js → chunk-QFPXZITP.js}

@@ -1,50 +1,24 @@
 import {
-  NETWORK_FEE_RATE,
-  confirmEscrowDebit,
   getBalance,
-  getCard,
   holdEscrow,
-  insertRequestLog,
-  recordEarning,
   releaseEscrow,
   resolveTargetCapability,
-  settleEscrow,
-  updateReputation
-} from "./chunk-MCED4GDW.js";
-import {
-  verifyEscrowReceipt
-} from "./chunk-EJKW57ZV.js";
+  settleEscrow
+} from "./chunk-NQANA6WH.js";
 import {
   loadConfig
 } from "./chunk-IVOYM3WG.js";
+import {
+  getCard,
+  insertRequestLog,
+  updateReputation
+} from "./chunk-ZU2TP7CN.js";
 import {
   AgentBnBError
-} from "./chunk-WVY2W7AA.js";
+} from "./chunk-I7KWA7OB.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;
@@ -123,23 +97,17 @@ async function executeCapabilityRequest(opts) {
     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" } };
+    if (creditsNeeded > 0) {
+      return {
+        success: false,
+        error: {
+          code: -32603,
+          message: "Direct HTTP paid remote settlement is disabled. Route paid requests through relay."
+        }
+      };
     }
-    isRemoteEscrow = true;
   } else {
     try {
       const balance = getBalance(creditDb, requester);
@@ -153,9 +121,8 @@ async function executeCapabilityRequest(opts) {
     }
   }
   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 (escrowId) releaseEscrow(creditDb, escrowId);
     if (failureReason === "bad_execution" || failureReason === "auth_error") {
       updateReputation(registryDb, cardId, false, latencyMs);
     }
@@ -174,15 +141,10 @@ async function executeCapabilityRequest(opts) {
       });
     } catch {
     }
-    return {
-      success: false,
-      error: { code: -32603, message, ...receiptData ? { data: receiptData } : {} }
-    };
+    return { success: false, error: { code: -32603, message } };
   };
   const handleSuccess = (result, latencyMs) => {
-    if (isRemoteEscrow && receipt) {
-      settleProviderEarning(creditDb, card.owner, receipt);
-    } else if (escrowId) {
+    if (escrowId) {
       settleEscrow(creditDb, escrowId, card.owner);
     }
     updateReputation(registryDb, cardId, true, latencyMs);
@@ -210,12 +172,7 @@ async function executeCapabilityRequest(opts) {
       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 };
+    return { success: true, result };
   };
   if (skillExecutor) {
     let targetSkillId = resolvedSkillId ?? skillId;
@@ -447,8 +404,6 @@ async function executeCapabilityBatch(options) {
 }
 
 export {
-  settleRequesterEscrow,
-  releaseRequesterEscrow,
   executeCapabilityRequest,
   executeCapabilityBatch
 };

package/dist/chunk-R4F4XII4.js

@@ -0,0 +1,264 @@
+import {
+  AgentBnBError
+} from "./chunk-I7KWA7OB.js";
+
+// src/gateway/client.ts
+import { randomUUID } from "crypto";
+import { Agent } from "undici";
+
+// src/credit/signing.ts
+import { generateKeyPairSync, sign, verify, createPublicKey, createPrivateKey } from "crypto";
+import { writeFileSync, readFileSync, existsSync, chmodSync } from "fs";
+import { join } from "path";
+function generateKeyPair() {
+  const { publicKey, privateKey } = generateKeyPairSync("ed25519", {
+    publicKeyEncoding: { type: "spki", format: "der" },
+    privateKeyEncoding: { type: "pkcs8", format: "der" }
+  });
+  return {
+    publicKey: Buffer.from(publicKey),
+    privateKey: Buffer.from(privateKey)
+  };
+}
+function saveKeyPair(configDir, keys) {
+  const privatePath = join(configDir, "private.key");
+  const publicPath = join(configDir, "public.key");
+  writeFileSync(privatePath, keys.privateKey);
+  chmodSync(privatePath, 384);
+  writeFileSync(publicPath, keys.publicKey);
+}
+function loadKeyPair(configDir) {
+  const privatePath = join(configDir, "private.key");
+  const publicPath = join(configDir, "public.key");
+  if (!existsSync(privatePath) || !existsSync(publicPath)) {
+    throw new AgentBnBError("Keypair not found. Run `agentbnb init` to generate one.", "KEYPAIR_NOT_FOUND");
+  }
+  return {
+    publicKey: readFileSync(publicPath),
+    privateKey: readFileSync(privatePath)
+  };
+}
+function canonicalJson(data) {
+  return JSON.stringify(sortForCanonicalJson(data));
+}
+function sortForCanonicalJson(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sortForCanonicalJson(item));
+  }
+  if (value !== null && typeof value === "object") {
+    const proto = Object.getPrototypeOf(value);
+    if (proto === Object.prototype || proto === null) {
+      const input = value;
+      const output = {};
+      const sortedKeys = Object.keys(input).sort();
+      for (const key of sortedKeys) {
+        output[key] = sortForCanonicalJson(input[key]);
+      }
+      return output;
+    }
+  }
+  return value;
+}
+function signEscrowReceipt(data, privateKey) {
+  const message = Buffer.from(canonicalJson(data), "utf-8");
+  const keyObject = createPrivateKey({ key: privateKey, format: "der", type: "pkcs8" });
+  const signature = sign(null, message, keyObject);
+  return signature.toString("base64url");
+}
+function verifyEscrowReceipt(data, signature, publicKey) {
+  try {
+    const message = Buffer.from(canonicalJson(data), "utf-8");
+    const keyObject = createPublicKey({ key: publicKey, format: "der", type: "spki" });
+    const sigBuffer = Buffer.from(signature, "base64url");
+    return verify(null, message, keyObject, sigBuffer);
+  } catch {
+    return false;
+  }
+}
+
+// src/gateway/client.ts
+var REQUEST_TIMEOUT_FALLBACK_MS = 3e5;
+var REQUEST_TIMEOUT_GRACE_MS = 3e4;
+var REQUEST_TIMEOUT_EXPECTED_MULTIPLIER = 1.5;
+var gatewayAgent = new Agent({
+  keepAliveTimeout: 3e4,
+  keepAliveMaxTimeout: 6e4,
+  connections: 10,
+  pipelining: 1
+});
+function deriveRequestTimeoutMs(hint) {
+  const expectedDurationMs = hint?.expected_duration_ms;
+  if (typeof expectedDurationMs === "number" && expectedDurationMs > 0) {
+    return Math.ceil(expectedDurationMs * REQUEST_TIMEOUT_EXPECTED_MULTIPLIER) + REQUEST_TIMEOUT_GRACE_MS;
+  }
+  const hardTimeoutMs = hint?.hard_timeout_ms;
+  if (typeof hardTimeoutMs === "number" && hardTimeoutMs > 0) {
+    return Math.ceil(hardTimeoutMs) + REQUEST_TIMEOUT_GRACE_MS;
+  }
+  return REQUEST_TIMEOUT_FALLBACK_MS;
+}
+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: timeoutOverrideMs,
+    timeoutHint,
+    escrowReceipt,
+    identity
+  } = opts;
+  const timeoutMs = timeoutOverrideMs ?? deriveRequestTimeoutMs(timeoutHint);
+  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,
+      timeoutHint: opts.timeoutHint,
+      identity: opts.identity
+    });
+    return /* @__PURE__ */ new Map([[item.id, result]]);
+  }
+  const { timeoutMs: timeoutOverrideMs, timeoutHint, identity } = opts;
+  const timeoutMs = timeoutOverrideMs ?? deriveRequestTimeoutMs(timeoutHint);
+  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) {
+  const timeoutMs = opts.timeoutMs ?? deriveRequestTimeoutMs(opts.timeoutHint);
+  try {
+    return await relay.request({
+      targetOwner: opts.targetOwner,
+      targetAgentId: opts.targetAgentId,
+      cardId: opts.cardId,
+      skillId: opts.skillId,
+      params: opts.params ?? {},
+      requester: opts.requester,
+      escrowReceipt: opts.escrowReceipt,
+      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 {
+  generateKeyPair,
+  saveKeyPair,
+  loadKeyPair,
+  signEscrowReceipt,
+  verifyEscrowReceipt,
+  REQUEST_TIMEOUT_FALLBACK_MS,
+  REQUEST_TIMEOUT_GRACE_MS,
+  REQUEST_TIMEOUT_EXPECTED_MULTIPLIER,
+  deriveRequestTimeoutMs,
+  requestCapability,
+  requestCapabilityBatch,
+  requestViaRelay
+};