agentbnb 4.0.2 → 5.1.0

package/dist/chunk-LCAIAAG2.js

@@ -0,0 +1,916 @@
+import {
+  confirmEscrowDebit,
+  getBalance,
+  holdEscrow,
+  initFeedbackTable,
+  recordEarning,
+  releaseEscrow,
+  settleEscrow,
+  verifyEscrowReceipt
+} from "./chunk-CRFCWD6V.js";
+import {
+  AgentBnBError,
+  AnyCardSchema,
+  CapabilityCardSchema
+} from "./chunk-WGZ5AGOX.js";
+
+// src/gateway/execute.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/registry/store.ts
+import Database from "better-sqlite3";
+
+// src/registry/request-log.ts
+var SINCE_MS = {
+  "24h": 864e5,
+  "7d": 6048e5,
+  "30d": 2592e6
+};
+function createRequestLogTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS request_log (
+      id TEXT PRIMARY KEY,
+      card_id TEXT NOT NULL,
+      card_name TEXT NOT NULL,
+      requester TEXT NOT NULL,
+      status TEXT NOT NULL CHECK(status IN ('success', 'failure', 'timeout')),
+      latency_ms INTEGER NOT NULL,
+      credits_charged INTEGER NOT NULL,
+      created_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS request_log_created_at_idx
+      ON request_log (created_at DESC);
+  `);
+  try {
+    db.exec("ALTER TABLE request_log ADD COLUMN skill_id TEXT");
+  } catch {
+  }
+  try {
+    db.exec("ALTER TABLE request_log ADD COLUMN action_type TEXT");
+  } catch {
+  }
+  try {
+    db.exec("ALTER TABLE request_log ADD COLUMN tier_invoked INTEGER");
+  } catch {
+  }
+}
+function insertRequestLog(db, entry) {
+  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(
+    entry.id,
+    entry.card_id,
+    entry.card_name,
+    entry.requester,
+    entry.status,
+    entry.latency_ms,
+    entry.credits_charged,
+    entry.created_at,
+    entry.skill_id ?? null,
+    entry.action_type ?? null,
+    entry.tier_invoked ?? null
+  );
+}
+function getSkillRequestCount(db, skillId, windowMs) {
+  const cutoff = new Date(Date.now() - windowMs).toISOString();
+  const stmt = db.prepare(
+    `SELECT COUNT(*) as cnt FROM request_log
+     WHERE skill_id = ? AND created_at >= ? AND status = 'success' AND action_type IS NULL`
+  );
+  const row = stmt.get(skillId, cutoff);
+  return row.cnt;
+}
+function getActivityFeed(db, limit = 20, since) {
+  const effectiveLimit = Math.min(limit, 100);
+  if (since !== void 0) {
+    const stmt2 = db.prepare(`
+      SELECT r.id, r.card_name, r.requester, c.owner AS provider,
+             r.status, r.credits_charged, r.latency_ms, r.created_at, r.action_type
+      FROM request_log r
+      LEFT JOIN capability_cards c ON r.card_id = c.id
+      WHERE (r.action_type IS NULL OR r.action_type IN ('auto_share', 'agent_joined'))
+        AND r.created_at > ?
+      ORDER BY r.created_at DESC
+      LIMIT ?
+    `);
+    return stmt2.all(since, effectiveLimit);
+  }
+  const stmt = db.prepare(`
+    SELECT r.id, r.card_name, r.requester, c.owner AS provider,
+           r.status, r.credits_charged, r.latency_ms, r.created_at, r.action_type
+    FROM request_log r
+    LEFT JOIN capability_cards c ON r.card_id = c.id
+    WHERE (r.action_type IS NULL OR r.action_type IN ('auto_share', 'agent_joined'))
+    ORDER BY r.created_at DESC
+    LIMIT ?
+  `);
+  return stmt.all(effectiveLimit);
+}
+function getRequestLog(db, limit = 10, since) {
+  if (since !== void 0) {
+    const cutoff = new Date(Date.now() - SINCE_MS[since]).toISOString();
+    const stmt2 = db.prepare(`
+      SELECT id, card_id, card_name, requester, status, latency_ms, credits_charged, created_at, skill_id, action_type, tier_invoked
+      FROM request_log
+      WHERE created_at >= ?
+      ORDER BY created_at DESC
+      LIMIT ?
+    `);
+    return stmt2.all(cutoff, limit);
+  }
+  const stmt = db.prepare(`
+    SELECT id, card_id, card_name, requester, status, latency_ms, credits_charged, created_at, skill_id, action_type, tier_invoked
+    FROM request_log
+    ORDER BY created_at DESC
+    LIMIT ?
+  `);
+  return stmt.all(limit);
+}
+
+// src/evolution/store.ts
+import { randomUUID } from "crypto";
+function initEvolutionTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS evolution_versions (
+      id TEXT PRIMARY KEY,
+      template_name TEXT NOT NULL,
+      template_version TEXT NOT NULL,
+      publisher_agent TEXT NOT NULL,
+      changelog TEXT NOT NULL,
+      core_memory_snapshot TEXT NOT NULL,
+      fitness_improvement REAL NOT NULL,
+      timestamp TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS evolution_template_idx
+      ON evolution_versions(template_name, created_at DESC);
+  `);
+}
+function insertEvolution(db, ev) {
+  const id = randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(`
+    INSERT INTO evolution_versions (
+      id, template_name, template_version, publisher_agent,
+      changelog, core_memory_snapshot, fitness_improvement, timestamp, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    id,
+    ev.template_name,
+    ev.template_version,
+    ev.publisher_agent,
+    ev.changelog,
+    JSON.stringify(ev.core_memory_snapshot),
+    ev.fitness_improvement,
+    ev.timestamp,
+    now
+  );
+  return id;
+}
+function getLatestEvolution(db, templateName) {
+  const row = db.prepare(`
+    SELECT * FROM evolution_versions
+    WHERE template_name = ?
+    ORDER BY created_at DESC
+    LIMIT 1
+  `).get(templateName);
+  if (!row) return null;
+  return rowToEvolution(row);
+}
+function getEvolutionHistory(db, templateName, limit = 20) {
+  const rows = db.prepare(`
+    SELECT * FROM evolution_versions
+    WHERE template_name = ?
+    ORDER BY created_at DESC
+    LIMIT ?
+  `).all(templateName, limit);
+  return rows.map(rowToEvolution);
+}
+function rowToEvolution(row) {
+  return {
+    template_name: row["template_name"],
+    template_version: row["template_version"],
+    publisher_agent: row["publisher_agent"],
+    changelog: row["changelog"],
+    core_memory_snapshot: JSON.parse(row["core_memory_snapshot"]),
+    fitness_improvement: row["fitness_improvement"],
+    timestamp: row["timestamp"]
+  };
+}
+
+// src/registry/store.ts
+var V2_FTS_TRIGGERS = `
+  DROP TRIGGER IF EXISTS cards_ai;
+  DROP TRIGGER IF EXISTS cards_au;
+  DROP TRIGGER IF EXISTS cards_ad;
+
+  CREATE TRIGGER cards_ai AFTER INSERT ON capability_cards BEGIN
+    INSERT INTO cards_fts(rowid, id, owner, name, description, tags)
+    VALUES (
+      new.rowid,
+      new.id,
+      new.owner,
+      COALESCE(
+        (SELECT group_concat(json_extract(value, '$.name'), ' ')
+         FROM json_each(json_extract(new.data, '$.skills'))),
+        json_extract(new.data, '$.name'),
+        ''
+      ),
+      COALESCE(
+        (SELECT group_concat(json_extract(value, '$.description'), ' ')
+         FROM json_each(json_extract(new.data, '$.skills'))),
+        json_extract(new.data, '$.description'),
+        ''
+      ),
+      COALESCE(
+        (SELECT group_concat(json_extract(value, '$.metadata.tags'), ' ')
+         FROM json_each(json_extract(new.data, '$.skills'))),
+        (SELECT group_concat(value, ' ')
+         FROM json_each(json_extract(new.data, '$.metadata.tags'))),
+        ''
+      )
+    );
+  END;
+
+  CREATE TRIGGER cards_au AFTER UPDATE ON capability_cards BEGIN
+    INSERT INTO cards_fts(cards_fts, rowid, id, owner, name, description, tags)
+    VALUES (
+      'delete',
+      old.rowid,
+      old.id,
+      old.owner,
+      COALESCE(
+        (SELECT group_concat(json_extract(value, '$.name'), ' ')
+         FROM json_each(json_extract(old.data, '$.skills'))),
+        json_extract(old.data, '$.name'),
+        ''
+      ),
+      COALESCE(
+        (SELECT group_concat(json_extract(value, '$.description'), ' ')
+         FROM json_each(json_extract(old.data, '$.skills'))),
+        json_extract(old.data, '$.description'),
+        ''
+      ),
+      COALESCE(
+        (SELECT group_concat(json_extract(value, '$.metadata.tags'), ' ')
+         FROM json_each(json_extract(old.data, '$.skills'))),
+        (SELECT group_concat(value, ' ')
+         FROM json_each(json_extract(old.data, '$.metadata.tags'))),
+        ''
+      )
+    );
+    INSERT INTO cards_fts(rowid, id, owner, name, description, tags)
+    VALUES (
+      new.rowid,
+      new.id,
+      new.owner,
+      COALESCE(
+        (SELECT group_concat(json_extract(value, '$.name'), ' ')
+         FROM json_each(json_extract(new.data, '$.skills'))),
+        json_extract(new.data, '$.name'),
+        ''
+      ),
+      COALESCE(
+        (SELECT group_concat(json_extract(value, '$.description'), ' ')
+         FROM json_each(json_extract(new.data, '$.skills'))),
+        json_extract(new.data, '$.description'),
+        ''
+      ),
+      COALESCE(
+        (SELECT group_concat(json_extract(value, '$.metadata.tags'), ' ')
+         FROM json_each(json_extract(new.data, '$.skills'))),
+        (SELECT group_concat(value, ' ')
+         FROM json_each(json_extract(new.data, '$.metadata.tags'))),
+        ''
+      )
+    );
+  END;
+
+  CREATE TRIGGER cards_ad AFTER DELETE ON capability_cards BEGIN
+    INSERT INTO cards_fts(cards_fts, rowid, id, owner, name, description, tags)
+    VALUES (
+      'delete',
+      old.rowid,
+      old.id,
+      old.owner,
+      COALESCE(
+        (SELECT group_concat(json_extract(value, '$.name'), ' ')
+         FROM json_each(json_extract(old.data, '$.skills'))),
+        json_extract(old.data, '$.name'),
+        ''
+      ),
+      COALESCE(
+        (SELECT group_concat(json_extract(value, '$.description'), ' ')
+         FROM json_each(json_extract(old.data, '$.skills'))),
+        json_extract(old.data, '$.description'),
+        ''
+      ),
+      COALESCE(
+        (SELECT group_concat(json_extract(value, '$.metadata.tags'), ' ')
+         FROM json_each(json_extract(old.data, '$.skills'))),
+        (SELECT group_concat(value, ' ')
+         FROM json_each(json_extract(old.data, '$.metadata.tags'))),
+        ''
+      )
+    );
+  END;
+`;
+function openDatabase(path = ":memory:") {
+  const db = new Database(path);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS capability_cards (
+      id TEXT PRIMARY KEY,
+      owner TEXT NOT NULL,
+      data TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS pending_requests (
+      id TEXT PRIMARY KEY,
+      skill_query TEXT NOT NULL,
+      max_cost_credits REAL NOT NULL,
+      selected_peer TEXT,
+      selected_card_id TEXT,
+      selected_skill_id TEXT,
+      credits REAL NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending',
+      params TEXT,
+      created_at TEXT NOT NULL,
+      resolved_at TEXT
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS cards_fts USING fts5(
+      id UNINDEXED,
+      owner,
+      name,
+      description,
+      tags,
+      content=""
+    );
+  `);
+  createRequestLogTable(db);
+  initFeedbackTable(db);
+  initEvolutionTable(db);
+  runMigrations(db);
+  return db;
+}
+function runMigrations(db) {
+  const version = db.pragma("user_version")[0]?.user_version ?? 0;
+  if (version < 2) {
+    migrateV1toV2(db);
+  }
+}
+function migrateV1toV2(db) {
+  const migrate = db.transaction(() => {
+    const rows = db.prepare("SELECT rowid, id, data FROM capability_cards").all();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const row of rows) {
+      const parsed = JSON.parse(row.data);
+      if (parsed["spec_version"] === "2.0") continue;
+      const v1 = parsed;
+      const v2 = {
+        spec_version: "2.0",
+        id: v1.id,
+        owner: v1.owner,
+        agent_name: v1.name,
+        skills: [
+          {
+            id: `skill-${v1.id}`,
+            name: v1.name,
+            description: v1.description,
+            level: v1.level,
+            inputs: v1.inputs,
+            outputs: v1.outputs,
+            pricing: v1.pricing,
+            availability: { online: v1.availability.online },
+            powered_by: v1.powered_by,
+            metadata: v1.metadata,
+            _internal: v1._internal
+          }
+        ],
+        availability: v1.availability,
+        created_at: v1.created_at,
+        updated_at: now
+      };
+      db.prepare("UPDATE capability_cards SET data = ?, updated_at = ? WHERE id = ?").run(
+        JSON.stringify(v2),
+        now,
+        v2.id
+      );
+    }
+    db.exec(V2_FTS_TRIGGERS);
+    db.exec(`INSERT INTO cards_fts(cards_fts) VALUES('delete-all')`);
+    const allRows = db.prepare("SELECT rowid, id, owner, data FROM capability_cards").all();
+    const ftsInsert = db.prepare(
+      "INSERT INTO cards_fts(rowid, id, owner, name, description, tags) VALUES (?, ?, ?, ?, ?, ?)"
+    );
+    for (const row of allRows) {
+      const data = JSON.parse(row.data);
+      const skills = data["skills"] ?? [];
+      let name;
+      let description;
+      let tags;
+      if (skills.length > 0) {
+        name = skills.map((s) => String(s["name"] ?? "")).join(" ");
+        description = skills.map((s) => String(s["description"] ?? "")).join(" ");
+        tags = skills.flatMap((s) => {
+          const meta = s["metadata"];
+          return meta?.["tags"] ?? [];
+        }).join(" ");
+      } else {
+        name = String(data["name"] ?? "");
+        description = String(data["description"] ?? "");
+        const meta = data["metadata"];
+        const rawTags = meta?.["tags"] ?? [];
+        tags = rawTags.join(" ");
+      }
+      ftsInsert.run(row.rowid, row.id, row.owner, name, description, tags);
+    }
+    db.pragma("user_version = 2");
+  });
+  migrate();
+}
+function insertCard(db, card) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const withTimestamps = { ...card, created_at: card.created_at ?? now, updated_at: now };
+  const parsed = CapabilityCardSchema.safeParse(withTimestamps);
+  if (!parsed.success) {
+    throw new AgentBnBError(
+      `Card validation failed: ${parsed.error.message}`,
+      "VALIDATION_ERROR"
+    );
+  }
+  const stmt = db.prepare(`
+    INSERT INTO capability_cards (id, owner, data, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?)
+  `);
+  stmt.run(
+    parsed.data.id,
+    parsed.data.owner,
+    JSON.stringify(parsed.data),
+    parsed.data.created_at ?? now,
+    parsed.data.updated_at ?? now
+  );
+}
+function getCard(db, id) {
+  const stmt = db.prepare("SELECT data FROM capability_cards WHERE id = ?");
+  const row = stmt.get(id);
+  if (!row) return null;
+  return JSON.parse(row.data);
+}
+function updateCard(db, id, owner, updates) {
+  const existing = getCard(db, id);
+  if (!existing) {
+    throw new AgentBnBError(`Card not found: ${id}`, "NOT_FOUND");
+  }
+  if (existing.owner !== owner) {
+    throw new AgentBnBError("Forbidden: you do not own this card", "FORBIDDEN");
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const merged = { ...existing, ...updates, updated_at: now };
+  const parsed = AnyCardSchema.safeParse(merged);
+  if (!parsed.success) {
+    throw new AgentBnBError(
+      `Card validation failed: ${parsed.error.message}`,
+      "VALIDATION_ERROR"
+    );
+  }
+  const stmt = db.prepare(`
+    UPDATE capability_cards
+    SET data = ?, updated_at = ?
+    WHERE id = ?
+  `);
+  stmt.run(JSON.stringify(parsed.data), now, id);
+}
+function updateReputation(db, cardId, success, latencyMs) {
+  const existing = getCard(db, cardId);
+  if (!existing) return;
+  const ALPHA = 0.1;
+  const observed = success ? 1 : 0;
+  const prevSuccessRate = existing.metadata?.success_rate;
+  const prevLatency = existing.metadata?.avg_latency_ms;
+  const newSuccessRate = prevSuccessRate === void 0 ? observed : ALPHA * observed + (1 - ALPHA) * prevSuccessRate;
+  const newLatency = prevLatency === void 0 ? latencyMs : ALPHA * latencyMs + (1 - ALPHA) * prevLatency;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const updatedMetadata = {
+    ...existing.metadata,
+    success_rate: Math.round(newSuccessRate * 1e3) / 1e3,
+    avg_latency_ms: Math.round(newLatency)
+  };
+  const updatedCard = { ...existing, metadata: updatedMetadata, updated_at: now };
+  const stmt = db.prepare(`
+    UPDATE capability_cards
+    SET data = ?, updated_at = ?
+    WHERE id = ?
+  `);
+  stmt.run(JSON.stringify(updatedCard), now, cardId);
+}
+function updateSkillAvailability(db, cardId, skillId, online) {
+  const row = db.prepare("SELECT data FROM capability_cards WHERE id = ?").get(cardId);
+  if (!row) return;
+  const card = JSON.parse(row.data);
+  const skills = card["skills"];
+  if (!skills) return;
+  const skill = skills.find((s) => s["id"] === skillId);
+  if (!skill) return;
+  const existing = skill["availability"] ?? {};
+  skill["availability"] = { ...existing, online };
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare("UPDATE capability_cards SET data = ?, updated_at = ? WHERE id = ?").run(
+    JSON.stringify(card),
+    now,
+    cardId
+  );
+}
+function updateSkillIdleRate(db, cardId, skillId, idleRate) {
+  const row = db.prepare("SELECT data FROM capability_cards WHERE id = ?").get(cardId);
+  if (!row) return;
+  const card = JSON.parse(row.data);
+  const skills = card["skills"];
+  if (!skills) return;
+  const skill = skills.find((s) => s["id"] === skillId);
+  if (!skill) return;
+  const existing = skill["_internal"] ?? {};
+  skill["_internal"] = {
+    ...existing,
+    idle_rate: idleRate,
+    idle_rate_computed_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare("UPDATE capability_cards SET data = ?, updated_at = ? WHERE id = ?").run(
+    JSON.stringify(card),
+    now,
+    cardId
+  );
+}
+function listCards(db, owner) {
+  let stmt;
+  let rows;
+  if (owner !== void 0) {
+    stmt = db.prepare("SELECT data FROM capability_cards WHERE owner = ?");
+    rows = stmt.all(owner);
+  } else {
+    stmt = db.prepare("SELECT data FROM capability_cards");
+    rows = stmt.all();
+  }
+  return rows.map((row) => JSON.parse(row.data));
+}
+
+// src/credit/settlement.ts
+function settleProviderEarning(providerDb, providerOwner, receipt) {
+  recordEarning(
+    providerDb,
+    providerOwner,
+    receipt.amount,
+    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 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}` } };
+  }
+  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) => {
+    if (!isRemoteEscrow && escrowId) releaseEscrow(creditDb, escrowId);
+    updateReputation(registryDb, cardId, false, latencyMs);
+    try {
+      insertRequestLog(registryDb, {
+        id: randomUUID2(),
+        card_id: cardId,
+        card_name: cardName,
+        skill_id: resolvedSkillId,
+        requester,
+        status,
+        latency_ms: latencyMs,
+        credits_charged: 0,
+        created_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } 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: randomUUID2(),
+        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 {
+    }
+    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) {
+    const targetSkillId = resolvedSkillId ?? skillId ?? cardId;
+    try {
+      const execResult = await skillExecutor.execute(targetSkillId, params, onProgress);
+      if (!execResult.success) {
+        return handleFailure("failure", execResult.latency_ms, execResult.error ?? "Execution failed");
+      }
+      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);
+    }
+  }
+  if (!handlerUrl) {
+    return handleFailure("failure", Date.now() - startMs, "No skill executor or handler URL configured");
+  }
+  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}`);
+    }
+    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"
+    );
+  }
+}
+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: randomUUID2(),
+        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 {
+  insertRequestLog,
+  getSkillRequestCount,
+  getActivityFeed,
+  getRequestLog,
+  insertEvolution,
+  getLatestEvolution,
+  getEvolutionHistory,
+  openDatabase,
+  insertCard,
+  getCard,
+  updateCard,
+  updateSkillAvailability,
+  updateSkillIdleRate,
+  listCards,
+  settleRequesterEscrow,
+  releaseRequesterEscrow,
+  executeCapabilityRequest,
+  executeCapabilityBatch
+};