agentbnb 2.2.0 → 3.0.0

package/dist/chunk-V7M6GIJZ.js

@@ -0,0 +1,666 @@
+import {
+  findPeer
+} from "./chunk-BEI5MTNZ.js";
+import {
+  AgentBnBError
+} from "./chunk-TQMI73LL.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 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);
+  return db;
+}
+function bootstrapAgent(db, owner, amount = 100) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.transaction(() => {
+    const result = db.prepare("INSERT OR IGNORE INTO credit_balances (owner, balance, updated_at) VALUES (?, ?, ?)").run(owner, amount, now);
+    if (result.changes > 0) {
+      db.prepare(
+        "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+      ).run(randomUUID(), owner, amount, "bootstrap", null, now);
+    }
+  })();
+}
+function getBalance(db, owner) {
+  const row = db.prepare("SELECT balance FROM credit_balances WHERE owner = ?").get(owner);
+  return row?.balance ?? 0;
+}
+function getTransactions(db, owner, limit = 100) {
+  return db.prepare(
+    "SELECT id, owner, amount, reason, reference_id, created_at FROM credit_transactions WHERE owner = ? ORDER BY created_at DESC LIMIT ?"
+  ).all(owner, limit);
+}
+function recordEarning(db, owner, amount, _cardId, receiptNonce) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.transaction(() => {
+    const existing = db.prepare(
+      "SELECT id FROM credit_transactions WHERE reference_id = ? AND reason = 'remote_earning'"
+    ).get(receiptNonce);
+    if (existing) return;
+    db.prepare(
+      "INSERT OR IGNORE INTO credit_balances (owner, balance, updated_at) VALUES (?, 0, ?)"
+    ).run(owner, now);
+    db.prepare(
+      "UPDATE credit_balances SET balance = balance + ?, updated_at = ? WHERE owner = ?"
+    ).run(amount, now, owner);
+    db.prepare(
+      "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+    ).run(randomUUID(), owner, amount, "remote_earning", receiptNonce, now);
+  })();
+}
+
+// src/autonomy/tiers.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var DEFAULT_AUTONOMY_CONFIG = {
+  tier1_max_credits: 0,
+  tier2_max_credits: 0
+};
+function getAutonomyTier(creditAmount, config) {
+  if (creditAmount < config.tier1_max_credits) return 1;
+  if (creditAmount < config.tier2_max_credits) return 2;
+  return 3;
+}
+function insertAuditEvent(db, event) {
+  const isShareEvent = event.type === "auto_share" || event.type === "auto_share_notify" || event.type === "auto_share_pending";
+  const cardId = isShareEvent ? "system" : event.card_id;
+  const creditsCharged = isShareEvent ? 0 : event.credits;
+  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(
+    randomUUID2(),
+    cardId,
+    "autonomy-audit",
+    "self",
+    "success",
+    0,
+    creditsCharged,
+    (/* @__PURE__ */ new Date()).toISOString(),
+    event.skill_id,
+    event.type,
+    event.tier_invoked
+  );
+}
+
+// src/credit/budget.ts
+var DEFAULT_BUDGET_CONFIG = {
+  reserve_credits: 20
+};
+var BudgetManager = class {
+  /**
+   * Creates a new BudgetManager.
+   *
+   * @param creditDb - The credit SQLite database instance.
+   * @param owner - Agent owner identifier.
+   * @param config - Budget configuration. Defaults to DEFAULT_BUDGET_CONFIG (20 credit reserve).
+   */
+  constructor(creditDb, owner, config = DEFAULT_BUDGET_CONFIG) {
+    this.creditDb = creditDb;
+    this.owner = owner;
+    this.config = config;
+  }
+  /**
+   * Returns the number of credits available for spending.
+   * Computed as: max(0, balance - reserve_credits).
+   * Always returns a non-negative number — never goes below zero.
+   *
+   * @returns Available credits (balance minus reserve, floored at 0).
+   */
+  availableCredits() {
+    const balance = getBalance(this.creditDb, this.owner);
+    return Math.max(0, balance - this.config.reserve_credits);
+  }
+  /**
+   * Returns true if spending `amount` credits is permitted by budget rules.
+   *
+   * Rules:
+   * - Zero-cost calls (amount <= 0) always return true.
+   * - Any positive amount requires availableCredits() >= amount.
+   * - If balance is at or below the reserve floor, all positive-cost calls return false.
+   *
+   * @param amount - Number of credits to spend.
+   * @returns true if the spend is allowed, false if it would breach the reserve floor.
+   */
+  canSpend(amount) {
+    if (amount <= 0) return true;
+    return this.availableCredits() >= amount;
+  }
+};
+
+// src/registry/matcher.ts
+function searchCards(db, query, filters = {}) {
+  const words = query.trim().split(/\s+/).map((w) => w.replace(/["*^{}():]/g, "")).filter((w) => w.length > 0);
+  if (words.length === 0) return [];
+  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));
+  if (filters.apis_used && filters.apis_used.length > 0) {
+    const requiredApis = filters.apis_used;
+    return results.filter((card) => {
+      const cardApis = card.metadata?.apis_used ?? [];
+      return requiredApis.every((api) => cardApis.includes(api));
+    });
+  }
+  return results;
+}
+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);
+  return rows.map((row) => JSON.parse(row.data));
+}
+
+// src/gateway/client.ts
+import { randomUUID as randomUUID3 } from "crypto";
+async function requestCapability(opts) {
+  const { gatewayUrl, token, cardId, params = {}, timeoutMs = 3e4, escrowReceipt } = opts;
+  const id = randomUUID3();
+  const payload = {
+    jsonrpc: "2.0",
+    id,
+    method: "capability.execute",
+    params: {
+      card_id: cardId,
+      ...params,
+      ...escrowReceipt ? { escrow_receipt: escrowReceipt } : {}
+    }
+  };
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(`${gatewayUrl}/rpc`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+  } 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;
+}
+
+// src/credit/escrow.ts
+import { randomUUID as randomUUID4 } from "crypto";
+function holdEscrow(db, owner, amount, cardId) {
+  const escrowId = randomUUID4();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const hold = db.transaction(() => {
+    const row = db.prepare("SELECT balance FROM credit_balances WHERE owner = ?").get(owner);
+    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, owner, amount);
+    db.prepare(
+      "INSERT INTO credit_escrow (id, owner, amount, card_id, status, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+    ).run(escrowId, owner, amount, cardId, "held", now);
+    db.prepare(
+      "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+    ).run(randomUUID4(), owner, -amount, "escrow_hold", escrowId, now);
+  });
+  hold();
+  return escrowId;
+}
+function settleEscrow(db, escrowId, recipientOwner) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const settle = db.transaction(() => {
+    const escrow = db.prepare("SELECT id, owner, amount, status FROM credit_escrow WHERE id = ?").get(escrowId);
+    if (!escrow) {
+      throw new AgentBnBError(`Escrow not found: ${escrowId}`, "ESCROW_NOT_FOUND");
+    }
+    if (escrow.status !== "held") {
+      throw new AgentBnBError(
+        `Escrow ${escrowId} is already ${escrow.status}`,
+        "ESCROW_ALREADY_SETTLED"
+      );
+    }
+    db.prepare(
+      "INSERT OR IGNORE INTO credit_balances (owner, balance, updated_at) VALUES (?, 0, ?)"
+    ).run(recipientOwner, now);
+    db.prepare(
+      "UPDATE credit_balances SET balance = balance + ?, updated_at = ? WHERE owner = ?"
+    ).run(escrow.amount, now, recipientOwner);
+    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(randomUUID4(), recipientOwner, escrow.amount, "settlement", escrowId, now);
+  });
+  settle();
+}
+function releaseEscrow(db, escrowId) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const release = db.transaction(() => {
+    const escrow = db.prepare("SELECT id, owner, amount, status FROM credit_escrow WHERE id = ?").get(escrowId);
+    if (!escrow) {
+      throw new AgentBnBError(`Escrow not found: ${escrowId}`, "ESCROW_NOT_FOUND");
+    }
+    if (escrow.status !== "held") {
+      throw new AgentBnBError(
+        `Escrow ${escrowId} is already ${escrow.status}`,
+        "ESCROW_ALREADY_SETTLED"
+      );
+    }
+    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(randomUUID4(), escrow.owner, escrow.amount, "refund", escrowId, now);
+  });
+  release();
+}
+function confirmEscrowDebit(db, escrowId) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const confirm = db.transaction(() => {
+    const escrow = db.prepare("SELECT id, owner, amount, status FROM credit_escrow WHERE id = ?").get(escrowId);
+    if (!escrow) {
+      throw new AgentBnBError(`Escrow not found: ${escrowId}`, "ESCROW_NOT_FOUND");
+    }
+    if (escrow.status !== "held") {
+      throw new AgentBnBError(
+        `Escrow ${escrowId} is already ${escrow.status}`,
+        "ESCROW_ALREADY_SETTLED"
+      );
+    }
+    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(randomUUID4(), escrow.owner, 0, "remote_settlement_confirmed", escrowId, now);
+  });
+  confirm();
+}
+
+// src/autonomy/pending-requests.ts
+import { randomUUID as randomUUID5 } from "crypto";
+function createPendingRequest(db, opts) {
+  const id = randomUUID5();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const paramsJson = opts.params !== void 0 ? JSON.stringify(opts.params) : null;
+  db.prepare(`
+    INSERT INTO pending_requests (
+      id, skill_query, max_cost_credits, selected_peer, selected_card_id,
+      selected_skill_id, credits, status, params, created_at, resolved_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?, NULL)
+  `).run(
+    id,
+    opts.skill_query,
+    opts.max_cost_credits,
+    opts.selected_peer ?? null,
+    opts.selected_card_id ?? null,
+    opts.selected_skill_id ?? null,
+    opts.credits,
+    paramsJson,
+    now
+  );
+  return id;
+}
+function listPendingRequests(db) {
+  const rows = db.prepare(`SELECT * FROM pending_requests WHERE status = 'pending' ORDER BY created_at DESC`).all();
+  return rows;
+}
+function resolvePendingRequest(db, id, resolution) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const result = db.prepare(
+    `UPDATE pending_requests SET status = ?, resolved_at = ? WHERE id = ?`
+  ).run(resolution, now, id);
+  if (result.changes === 0) {
+    throw new AgentBnBError(
+      `Pending request not found: ${id}`,
+      "NOT_FOUND"
+    );
+  }
+}
+
+// src/autonomy/auto-request.ts
+function minMaxNormalize(values) {
+  if (values.length === 0) return [];
+  if (values.length === 1) return [1];
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  if (max === min) {
+    return values.map(() => 1);
+  }
+  return values.map((v) => (v - min) / (max - min));
+}
+function scorePeers(candidates, selfOwner) {
+  const eligible = candidates.filter((c) => c.card.owner !== selfOwner);
+  if (eligible.length === 0) return [];
+  const successRates = eligible.map((c) => c.card.metadata?.success_rate ?? 0.5);
+  const costEfficiencies = eligible.map((c) => c.cost === 0 ? 1 : 1 / c.cost);
+  const idleRates = eligible.map((c) => {
+    const internal = c.card._internal;
+    const idleRate = internal?.idle_rate;
+    return typeof idleRate === "number" ? idleRate : 1;
+  });
+  const normSuccess = minMaxNormalize(successRates);
+  const normCost = minMaxNormalize(costEfficiencies);
+  const normIdle = minMaxNormalize(idleRates);
+  const scored = eligible.map((c, i) => ({
+    ...c,
+    rawScore: (normSuccess[i] ?? 0) * (normCost[i] ?? 0) * (normIdle[i] ?? 0)
+  }));
+  scored.sort((a, b) => b.rawScore - a.rawScore);
+  return scored;
+}
+var AutoRequestor = class {
+  owner;
+  registryDb;
+  creditDb;
+  autonomyConfig;
+  budgetManager;
+  /**
+   * Creates a new AutoRequestor.
+   *
+   * @param opts - Configuration for this AutoRequestor instance.
+   */
+  constructor(opts) {
+    this.owner = opts.owner;
+    this.registryDb = opts.registryDb;
+    this.creditDb = opts.creditDb;
+    this.autonomyConfig = opts.autonomyConfig;
+    this.budgetManager = opts.budgetManager;
+  }
+  /**
+   * Executes an autonomous capability request.
+   *
+   * Performs the full flow:
+   * 1. Search for matching capability cards
+   * 2. Filter self-owned and over-budget candidates
+   * 3. Score candidates using min-max normalized composite scoring
+   * 4. Resolve peer gateway config
+   * 5. Check autonomy tier (Tier 3 queues to pending_requests)
+   * 6. Check budget reserve
+   * 7. Hold escrow
+   * 8. Execute via peer gateway
+   * 9. Settle or release escrow based on outcome
+   * 10. Log audit event (for Tier 2 notifications and all failures)
+   *
+   * @param need - The capability need to fulfill.
+   * @returns The result of the auto-request attempt.
+   */
+  async requestWithAutonomy(need) {
+    const cards = searchCards(this.registryDb, need.query, { online: true });
+    const candidates = [];
+    for (const card of cards) {
+      const cardAsV2 = card;
+      if (Array.isArray(cardAsV2.skills)) {
+        for (const skill of cardAsV2.skills) {
+          const cost = skill.pricing.credits_per_call;
+          if (cost <= need.maxCostCredits) {
+            candidates.push({ card, cost, skillId: skill.id });
+          }
+        }
+      } else {
+        const cost = card.pricing.credits_per_call;
+        if (cost <= need.maxCostCredits) {
+          candidates.push({ card, cost, skillId: void 0 });
+        }
+      }
+    }
+    const scored = scorePeers(candidates, this.owner);
+    if (scored.length === 0) {
+      this.logFailure("auto_request_failed", "system", "none", 3, 0, "none", "No eligible peer found");
+      return { status: "no_peer", reason: "No eligible peer found" };
+    }
+    const top = scored[0];
+    const peerConfig = findPeer(top.card.owner);
+    if (!peerConfig) {
+      this.logFailure("auto_request_failed", top.card.id, top.skillId ?? "none", 3, top.cost, top.card.owner, "No gateway config for peer");
+      return { status: "no_peer", reason: "No gateway config for peer" };
+    }
+    const tier = getAutonomyTier(top.cost, this.autonomyConfig);
+    if (tier === 3) {
+      createPendingRequest(this.registryDb, {
+        skill_query: need.query,
+        max_cost_credits: need.maxCostCredits,
+        credits: top.cost,
+        selected_peer: top.card.owner,
+        selected_card_id: top.card.id,
+        selected_skill_id: top.skillId,
+        params: need.params
+      });
+      insertAuditEvent(this.registryDb, {
+        type: "auto_request_pending",
+        card_id: top.card.id,
+        skill_id: top.skillId ?? top.card.id,
+        tier_invoked: 3,
+        credits: top.cost,
+        peer: top.card.owner
+      });
+      return {
+        status: "tier_blocked",
+        reason: "Tier 3: owner approval required",
+        peer: top.card.owner
+      };
+    }
+    if (!this.budgetManager.canSpend(top.cost)) {
+      this.logFailure("auto_request_failed", top.card.id, top.skillId ?? "none", tier, top.cost, top.card.owner, "Budget reserve would be breached");
+      return { status: "budget_blocked", reason: "Insufficient credits \u2014 reserve floor would be breached" };
+    }
+    const escrowId = holdEscrow(this.creditDb, this.owner, top.cost, top.card.id);
+    try {
+      const execResult = await requestCapability({
+        gatewayUrl: peerConfig.url,
+        token: peerConfig.token,
+        cardId: top.card.id,
+        params: top.skillId ? { skill_id: top.skillId, ...need.params } : need.params
+      });
+      settleEscrow(this.creditDb, escrowId, top.card.owner);
+      if (tier === 2) {
+        insertAuditEvent(this.registryDb, {
+          type: "auto_request_notify",
+          card_id: top.card.id,
+          skill_id: top.skillId ?? top.card.id,
+          tier_invoked: 2,
+          credits: top.cost,
+          peer: top.card.owner
+        });
+      } else {
+        insertAuditEvent(this.registryDb, {
+          type: "auto_request",
+          card_id: top.card.id,
+          skill_id: top.skillId ?? top.card.id,
+          tier_invoked: 1,
+          credits: top.cost,
+          peer: top.card.owner
+        });
+      }
+      return {
+        status: "success",
+        result: execResult,
+        escrowId,
+        peer: top.card.owner,
+        creditsSpent: top.cost
+      };
+    } catch (err) {
+      releaseEscrow(this.creditDb, escrowId);
+      const reason = err instanceof Error ? err.message : String(err);
+      this.logFailure("auto_request_failed", top.card.id, top.skillId ?? "none", tier, top.cost, top.card.owner, `Execution failed: ${reason}`);
+      return {
+        status: "failed",
+        reason: `Execution failed: ${reason}`,
+        peer: top.card.owner
+      };
+    }
+  }
+  /**
+   * Logs a failure audit event to request_log.
+   * Used for all non-success paths to satisfy REQ-06.
+   */
+  logFailure(type, cardId, skillId, tier, credits, peer, reason) {
+    insertAuditEvent(this.registryDb, {
+      type,
+      card_id: cardId,
+      skill_id: skillId,
+      tier_invoked: tier,
+      credits,
+      peer,
+      reason
+    });
+  }
+};
+
+// src/utils/interpolation.ts
+function resolvePath(obj, path) {
+  const segments = path.replace(/\[(\d+)\]/g, ".$1").split(".").filter((s) => s.length > 0);
+  let current = obj;
+  for (const segment of segments) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    if (typeof current !== "object") {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function interpolate(template, context) {
+  return template.replace(/\$\{([^}]+)\}/g, (_match, expression) => {
+    const resolved = resolvePath(context, expression.trim());
+    if (resolved === void 0 || resolved === null) {
+      return "";
+    }
+    if (typeof resolved === "object") {
+      return JSON.stringify(resolved);
+    }
+    return String(resolved);
+  });
+}
+function interpolateObject(obj, context) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    result[key] = interpolateValue(value, context);
+  }
+  return result;
+}
+function interpolateValue(value, context) {
+  if (typeof value === "string") {
+    return interpolate(value, context);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => interpolateValue(item, context));
+  }
+  if (value !== null && typeof value === "object") {
+    return interpolateObject(value, context);
+  }
+  return value;
+}
+
+export {
+  holdEscrow,
+  settleEscrow,
+  releaseEscrow,
+  confirmEscrowDebit,
+  openCreditDb,
+  bootstrapAgent,
+  getBalance,
+  getTransactions,
+  recordEarning,
+  DEFAULT_AUTONOMY_CONFIG,
+  getAutonomyTier,
+  insertAuditEvent,
+  DEFAULT_BUDGET_CONFIG,
+  BudgetManager,
+  searchCards,
+  filterCards,
+  requestCapability,
+  listPendingRequests,
+  resolvePendingRequest,
+  scorePeers,
+  AutoRequestor,
+  interpolateObject
+};