agentbnb 4.0.4 → 5.1.1

package/dist/chunk-C6KPAFCC.js

@@ -0,0 +1,387 @@
+// src/relay/websocket-client.ts
+import WebSocket from "ws";
+import { randomUUID } from "crypto";
+
+// src/relay/types.ts
+import { z } from "zod";
+var RegisterMessageSchema = z.object({
+  type: z.literal("register"),
+  owner: z.string().min(1),
+  token: z.string().min(1),
+  card: z.record(z.unknown()),
+  // CapabilityCard (validated separately)
+  cards: z.array(z.record(z.unknown())).optional()
+  // Additional cards (e.g., conductor card)
+});
+var RegisteredMessageSchema = z.object({
+  type: z.literal("registered"),
+  agent_id: z.string()
+});
+var RelayRequestMessageSchema = z.object({
+  type: z.literal("relay_request"),
+  id: z.string().uuid(),
+  target_owner: z.string().min(1),
+  card_id: z.string(),
+  skill_id: z.string().optional(),
+  params: z.record(z.unknown()).default({}),
+  requester: z.string().optional(),
+  escrow_receipt: z.record(z.unknown()).optional()
+});
+var IncomingRequestMessageSchema = z.object({
+  type: z.literal("incoming_request"),
+  id: z.string().uuid(),
+  from_owner: z.string().min(1),
+  card_id: z.string(),
+  skill_id: z.string().optional(),
+  params: z.record(z.unknown()).default({}),
+  requester: z.string().optional(),
+  escrow_receipt: z.record(z.unknown()).optional()
+});
+var RelayResponseMessageSchema = z.object({
+  type: z.literal("relay_response"),
+  id: z.string().uuid(),
+  result: z.unknown().optional(),
+  error: z.object({
+    code: z.number(),
+    message: z.string()
+  }).optional()
+});
+var ResponseMessageSchema = z.object({
+  type: z.literal("response"),
+  id: z.string().uuid(),
+  result: z.unknown().optional(),
+  error: z.object({
+    code: z.number(),
+    message: z.string()
+  }).optional()
+});
+var ErrorMessageSchema = z.object({
+  type: z.literal("error"),
+  code: z.string(),
+  message: z.string(),
+  request_id: z.string().optional()
+});
+var RelayProgressMessageSchema = z.object({
+  type: z.literal("relay_progress"),
+  id: z.string().uuid(),
+  // request ID this progress relates to
+  progress: z.number().min(0).max(100).optional(),
+  // optional percentage
+  message: z.string().optional()
+  // optional status message
+});
+var RelayMessageSchema = z.discriminatedUnion("type", [
+  RegisterMessageSchema,
+  RegisteredMessageSchema,
+  RelayRequestMessageSchema,
+  IncomingRequestMessageSchema,
+  RelayResponseMessageSchema,
+  ResponseMessageSchema,
+  ErrorMessageSchema,
+  RelayProgressMessageSchema
+]);
+
+// src/relay/websocket-client.ts
+var RelayClient = class {
+  ws = null;
+  opts;
+  pendingRequests = /* @__PURE__ */ new Map();
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  intentionalClose = false;
+  registered = false;
+  pongTimeout = null;
+  pingInterval = null;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  /**
+   * Connect to the registry relay and register.
+   * Resolves when registration is acknowledged.
+   */
+  async connect() {
+    return new Promise((resolve, reject) => {
+      this.intentionalClose = false;
+      this.registered = false;
+      const wsUrl = this.buildWsUrl();
+      this.ws = new WebSocket(wsUrl);
+      let resolved = false;
+      this.ws.on("open", () => {
+        this.reconnectAttempts = 0;
+        this.startPingInterval();
+        this.send({
+          type: "register",
+          owner: this.opts.owner,
+          token: this.opts.token,
+          card: this.opts.card,
+          ...this.opts.cards && this.opts.cards.length > 0 ? { cards: this.opts.cards } : {}
+        });
+      });
+      this.ws.on("message", (raw) => {
+        this.handleMessage(raw, (err) => {
+          if (!resolved) {
+            resolved = true;
+            if (err) reject(err);
+            else resolve();
+          }
+        });
+      });
+      this.ws.on("close", () => {
+        this.cleanup();
+        if (!this.intentionalClose) {
+          if (!resolved) {
+            resolved = true;
+            reject(new Error("WebSocket closed before registration"));
+          }
+          this.scheduleReconnect();
+        }
+      });
+      this.ws.on("error", (err) => {
+        if (!resolved) {
+          resolved = true;
+          reject(err);
+        }
+      });
+      setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          reject(new Error("Connection timeout"));
+          this.ws?.close();
+        }
+      }, 1e4);
+    });
+  }
+  /**
+   * Disconnect from the registry relay.
+   */
+  disconnect() {
+    this.intentionalClose = true;
+    this.cleanup();
+    if (this.ws) {
+      try {
+        this.ws.close(1e3, "Client disconnect");
+      } catch {
+      }
+      this.ws = null;
+    }
+    for (const [id, pending] of this.pendingRequests) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error("Client disconnected"));
+      this.pendingRequests.delete(id);
+    }
+  }
+  /**
+   * Send a relay request to another agent via the registry.
+   * @returns The result from the target agent.
+   */
+  async request(opts) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN || !this.registered) {
+      throw new Error("Not connected to registry relay");
+    }
+    const id = randomUUID();
+    const timeoutMs = opts.timeoutMs ?? 3e5;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error("Relay request timeout"));
+      }, timeoutMs);
+      this.pendingRequests.set(id, { resolve, reject, timeout, timeoutMs, onProgress: opts.onProgress });
+      this.send({
+        type: "relay_request",
+        id,
+        target_owner: opts.targetOwner,
+        card_id: opts.cardId,
+        skill_id: opts.skillId,
+        params: opts.params,
+        requester: opts.requester ?? this.opts.owner,
+        escrow_receipt: opts.escrowReceipt
+      });
+    });
+  }
+  /**
+   * 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.
+   *
+   * @param requestId - The relay request ID to associate progress with.
+   * @param info - Progress details (step, total, message).
+   */
+  sendProgress(requestId, info) {
+    this.send({
+      type: "relay_progress",
+      id: requestId,
+      progress: Math.round(info.step / info.total * 100),
+      message: info.message
+    });
+  }
+  /** Whether the client is connected and registered */
+  get isConnected() {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN && this.registered;
+  }
+  // ── Private methods ─────────────────────────────────────────────────────────
+  buildWsUrl() {
+    let url = this.opts.registryUrl;
+    if (url.startsWith("http://")) {
+      url = "ws://" + url.slice(7);
+    } else if (url.startsWith("https://")) {
+      url = "wss://" + url.slice(8);
+    } else if (!url.startsWith("ws://") && !url.startsWith("wss://")) {
+      url = "wss://" + url;
+    }
+    if (!url.endsWith("/ws")) {
+      url = url.replace(/\/$/, "") + "/ws";
+    }
+    return url;
+  }
+  handleMessage(raw, onRegistered) {
+    let data;
+    try {
+      data = JSON.parse(typeof raw === "string" ? raw : raw.toString("utf-8"));
+    } catch {
+      return;
+    }
+    const parsed = RelayMessageSchema.safeParse(data);
+    if (!parsed.success) return;
+    const msg = parsed.data;
+    switch (msg.type) {
+      case "registered":
+        this.registered = true;
+        if (!this.opts.silent) {
+          console.log(`  \u2713 Registered with registry (agent_id: ${msg.agent_id})`);
+        }
+        onRegistered?.();
+        break;
+      case "incoming_request":
+        this.handleIncomingRequest(msg);
+        break;
+      case "response":
+        this.handleResponse(msg);
+        break;
+      case "error":
+        this.handleError(msg);
+        break;
+      case "relay_progress":
+        this.handleProgress(msg);
+        break;
+      default:
+        break;
+    }
+  }
+  async handleIncomingRequest(msg) {
+    try {
+      const result = await this.opts.onRequest(msg);
+      this.send({
+        type: "relay_response",
+        id: msg.id,
+        result: result.result,
+        error: result.error
+      });
+    } catch (err) {
+      this.send({
+        type: "relay_response",
+        id: msg.id,
+        error: {
+          code: -32603,
+          message: err instanceof Error ? err.message : "Internal error"
+        }
+      });
+    }
+  }
+  handleResponse(msg) {
+    const pending = this.pendingRequests.get(msg.id);
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    this.pendingRequests.delete(msg.id);
+    if (msg.error) {
+      pending.reject(new Error(msg.error.message));
+    } else {
+      pending.resolve(msg.result);
+    }
+  }
+  handleError(msg) {
+    if (msg.request_id) {
+      const pending = this.pendingRequests.get(msg.request_id);
+      if (pending) {
+        clearTimeout(pending.timeout);
+        this.pendingRequests.delete(msg.request_id);
+        pending.reject(new Error(`${msg.code}: ${msg.message}`));
+      }
+    }
+  }
+  handleProgress(msg) {
+    const pending = this.pendingRequests.get(msg.id);
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    const newTimeout = setTimeout(() => {
+      this.pendingRequests.delete(msg.id);
+      pending.reject(new Error("Relay request timeout"));
+    }, pending.timeoutMs);
+    pending.timeout = newTimeout;
+    if (pending.onProgress) {
+      pending.onProgress({ id: msg.id, progress: msg.progress, message: msg.message });
+    }
+  }
+  send(msg) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+  startPingInterval() {
+    this.stopPingInterval();
+    this.pingInterval = setInterval(() => {
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        this.ws.ping();
+        this.pongTimeout = setTimeout(() => {
+          if (!this.opts.silent) {
+            console.log("  \u26A0 Registry pong timeout, reconnecting...");
+          }
+          this.ws?.terminate();
+        }, 15e3);
+      }
+    }, 3e4);
+    this.ws?.on("pong", () => {
+      if (this.pongTimeout) {
+        clearTimeout(this.pongTimeout);
+        this.pongTimeout = null;
+      }
+    });
+  }
+  stopPingInterval() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+    if (this.pongTimeout) {
+      clearTimeout(this.pongTimeout);
+      this.pongTimeout = null;
+    }
+  }
+  cleanup() {
+    this.stopPingInterval();
+    this.registered = false;
+  }
+  scheduleReconnect() {
+    if (this.intentionalClose) return;
+    if (this.reconnectTimer) return;
+    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
+    this.reconnectAttempts++;
+    if (!this.opts.silent) {
+      console.log(`  \u21BB Reconnecting to registry in ${delay / 1e3}s...`);
+    }
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      try {
+        await this.connect();
+        if (!this.opts.silent) {
+          console.log("  \u2713 Reconnected to registry");
+        }
+      } catch {
+      }
+    }, delay);
+  }
+};
+
+export {
+  RelayMessageSchema,
+  RelayClient
+};

package/dist/{chunk-JXEOE7HX.js → chunk-CRFCWD6V.js}

@@ -1,46 +1,10 @@
 import {
   AgentBnBError
-} from "./chunk-UB2NPFC7.js";
-
-// src/autonomy/tiers.ts
-import { randomUUID } 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(
-    randomUUID(),
-    cardId,
-    "autonomy-audit",
-    "self",
-    "success",
-    0,
-    creditsCharged,
-    (/* @__PURE__ */ new Date()).toISOString(),
-    event.skill_id,
-    event.type,
-    event.tier_invoked
-  );
-}
+} from "./chunk-WGZ5AGOX.js";
 
 // src/credit/ledger.ts
 import Database from "better-sqlite3";
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID } from "crypto";
 var CREDIT_SCHEMA = `
   CREATE TABLE IF NOT EXISTS credit_balances (
     owner TEXT PRIMARY KEY,
@@ -77,10 +41,26 @@ function openCreditDb(path = ":memory:") {
   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(() => {
@@ -96,14 +76,33 @@ function recordEarning(db, owner, amount, _cardId, receiptNonce) {
     ).run(amount, now, owner);
     db.prepare(
       "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-    ).run(randomUUID2(), owner, amount, "remote_earning", receiptNonce, now);
+    ).run(randomUUID(), owner, amount, "remote_earning", receiptNonce, now);
+  })();
+}
+function migrateOwner(db, oldOwner, newOwner) {
+  if (oldOwner === newOwner) return;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.transaction(() => {
+    const oldRow = db.prepare("SELECT balance FROM credit_balances WHERE owner = ?").get(oldOwner);
+    if (!oldRow) return;
+    const newRow = db.prepare("SELECT balance FROM credit_balances WHERE owner = ?").get(newOwner);
+    if (newRow) {
+      db.prepare("UPDATE credit_balances SET balance = balance + ?, updated_at = ? WHERE owner = ?").run(oldRow.balance, now, newOwner);
+    } else {
+      db.prepare("UPDATE credit_balances SET owner = ?, updated_at = ? WHERE owner = ?").run(newOwner, now, oldOwner);
+    }
+    if (newRow) {
+      db.prepare("DELETE FROM credit_balances WHERE owner = ?").run(oldOwner);
+    }
+    db.prepare("UPDATE credit_transactions SET owner = ? WHERE owner = ?").run(newOwner, oldOwner);
+    db.prepare("UPDATE credit_escrow SET owner = ? WHERE owner = ?").run(newOwner, oldOwner);
   })();
 }
 
 // src/credit/escrow.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 function holdEscrow(db, owner, amount, cardId) {
-  const escrowId = randomUUID3();
+  const escrowId = randomUUID2();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const hold = db.transaction(() => {
     const row = db.prepare("SELECT balance FROM credit_balances WHERE owner = ?").get(owner);
@@ -118,7 +117,7 @@ function holdEscrow(db, owner, amount, cardId) {
     ).run(escrowId, owner, amount, cardId, "held", now);
     db.prepare(
       "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-    ).run(randomUUID3(), owner, -amount, "escrow_hold", escrowId, now);
+    ).run(randomUUID2(), owner, -amount, "escrow_hold", escrowId, now);
   });
   hold();
   return escrowId;
@@ -147,7 +146,7 @@ function settleEscrow(db, escrowId, recipientOwner) {
     ).run("settled", now, escrowId);
     db.prepare(
       "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-    ).run(randomUUID3(), recipientOwner, escrow.amount, "settlement", escrowId, now);
+    ).run(randomUUID2(), recipientOwner, escrow.amount, "settlement", escrowId, now);
   });
   settle();
 }
@@ -172,56 +171,31 @@ function releaseEscrow(db, escrowId) {
     ).run("released", now, escrowId);
     db.prepare(
       "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-    ).run(randomUUID3(), escrow.owner, escrow.amount, "refund", escrowId, now);
+    ).run(randomUUID2(), escrow.owner, escrow.amount, "refund", escrowId, now);
   });
   release();
 }
-
-// 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 "";
+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 (typeof resolved === "object") {
-      return JSON.stringify(resolved);
+    if (escrow.status !== "held") {
+      throw new AgentBnBError(
+        `Escrow ${escrowId} is already ${escrow.status}`,
+        "ESCROW_ALREADY_SETTLED"
+      );
     }
-    return String(resolved);
+    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(randomUUID2(), escrow.owner, 0, "remote_settlement_confirmed", escrowId, now);
   });
-}
-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;
+  confirm();
 }
 
 // src/credit/signing.ts
@@ -276,20 +250,117 @@ function verifyEscrowReceipt(data, signature, publicKey) {
   }
 }
 
+// src/feedback/store.ts
+import { randomUUID as randomUUID3 } from "crypto";
+function initFeedbackTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS feedback (
+      id TEXT PRIMARY KEY,
+      transaction_id TEXT NOT NULL,
+      provider_agent TEXT NOT NULL,
+      skill_id TEXT NOT NULL,
+      requester_agent TEXT NOT NULL,
+      rating INTEGER NOT NULL,
+      latency_ms INTEGER NOT NULL,
+      result_quality TEXT NOT NULL,
+      quality_details TEXT,
+      would_reuse INTEGER NOT NULL,
+      cost_value_ratio TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS feedback_provider_idx ON feedback(provider_agent);
+    CREATE INDEX IF NOT EXISTS feedback_skill_idx ON feedback(skill_id);
+  `);
+}
+function insertFeedback(db, feedback) {
+  const id = randomUUID3();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(`
+    INSERT INTO feedback (
+      id, transaction_id, provider_agent, skill_id, requester_agent,
+      rating, latency_ms, result_quality, quality_details,
+      would_reuse, cost_value_ratio, timestamp, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    id,
+    feedback.transaction_id,
+    feedback.provider_agent,
+    feedback.skill_id,
+    feedback.requester_agent,
+    feedback.rating,
+    feedback.latency_ms,
+    feedback.result_quality,
+    feedback.quality_details ?? null,
+    feedback.would_reuse ? 1 : 0,
+    feedback.cost_value_ratio,
+    feedback.timestamp,
+    now
+  );
+  return id;
+}
+function getFeedbackForSkill(db, skillId, limit = 20) {
+  const rows = db.prepare(`
+    SELECT * FROM feedback
+    WHERE skill_id = ?
+    ORDER BY timestamp DESC
+    LIMIT ?
+  `).all(skillId, limit);
+  return rows.map(rowToFeedback);
+}
+function getFeedbackForProvider(db, providerAgent, sinceDays) {
+  let rows;
+  if (sinceDays !== void 0) {
+    rows = db.prepare(`
+      SELECT * FROM feedback
+      WHERE provider_agent = ?
+        AND timestamp >= datetime('now', ? || ' days')
+      ORDER BY timestamp DESC
+    `).all(providerAgent, `-${sinceDays}`);
+  } else {
+    rows = db.prepare(`
+      SELECT * FROM feedback
+      WHERE provider_agent = ?
+      ORDER BY timestamp DESC
+    `).all(providerAgent);
+  }
+  return rows.map(rowToFeedback);
+}
+function rowToFeedback(row) {
+  return {
+    transaction_id: row["transaction_id"],
+    provider_agent: row["provider_agent"],
+    skill_id: row["skill_id"],
+    requester_agent: row["requester_agent"],
+    rating: row["rating"],
+    latency_ms: row["latency_ms"],
+    result_quality: row["result_quality"],
+    quality_details: row["quality_details"] ?? void 0,
+    would_reuse: row["would_reuse"] === 1,
+    cost_value_ratio: row["cost_value_ratio"],
+    timestamp: row["timestamp"]
+  };
+}
+
 export {
+  initFeedbackTable,
+  insertFeedback,
+  getFeedbackForSkill,
+  getFeedbackForProvider,
   openCreditDb,
+  bootstrapAgent,
   getBalance,
+  getTransactions,
   recordEarning,
+  migrateOwner,
   holdEscrow,
   settleEscrow,
   releaseEscrow,
-  interpolateObject,
+  confirmEscrowDebit,
   generateKeyPair,
   saveKeyPair,
   loadKeyPair,
   signEscrowReceipt,
-  verifyEscrowReceipt,
-  DEFAULT_AUTONOMY_CONFIG,
-  getAutonomyTier,
-  insertAuditEvent
+  verifyEscrowReceipt
 };