agentbnb 8.2.2 → 8.3.0

package/dist/chunk-U6LP4KWN.js

@@ -0,0 +1,238 @@
+import {
+  ensureAgentsTable,
+  resolveCanonicalIdentity
+} from "./chunk-WTHMHNKC.js";
+
+// src/credit/owner-normalization.ts
+var RESERVED_OWNERS = /* @__PURE__ */ new Set(["platform_treasury"]);
+function tableExists(db, table) {
+  const row = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(table);
+  return row !== void 0;
+}
+function mergeBalanceRows(db, oldOwner, newOwner, now) {
+  if (!tableExists(db, "credit_balances")) return;
+  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);
+    db.prepare("DELETE FROM credit_balances WHERE owner = ?").run(oldOwner);
+    return;
+  }
+  db.prepare("UPDATE credit_balances SET owner = ?, updated_at = ? WHERE owner = ?").run(
+    newOwner,
+    now,
+    oldOwner
+  );
+}
+function mergeProviderRegistryRows(db, oldOwner, newOwner) {
+  if (!tableExists(db, "provider_registry")) return;
+  const oldRow = db.prepare("SELECT provider_number FROM provider_registry WHERE owner = ?").get(oldOwner);
+  if (!oldRow) return;
+  const newRow = db.prepare("SELECT provider_number FROM provider_registry WHERE owner = ?").get(newOwner);
+  if (newRow) {
+    db.prepare("DELETE FROM provider_registry WHERE owner = ?").run(oldOwner);
+    return;
+  }
+  db.prepare("UPDATE provider_registry SET owner = ? WHERE owner = ?").run(newOwner, oldOwner);
+}
+function mergeReliabilityRows(db, oldOwner, newOwner, now) {
+  if (!tableExists(db, "provider_reliability_metrics")) return;
+  const oldRow = db.prepare("SELECT * FROM provider_reliability_metrics WHERE owner = ?").get(oldOwner);
+  if (!oldRow) return;
+  const newRow = db.prepare("SELECT * FROM provider_reliability_metrics WHERE owner = ?").get(newOwner);
+  if (!newRow) {
+    db.prepare(
+      "UPDATE provider_reliability_metrics SET owner = ?, updated_at = ? WHERE owner = ?"
+    ).run(newOwner, now, oldOwner);
+    return;
+  }
+  const cycleStartCandidates = [oldRow.cycle_start, newRow.cycle_start].filter(Boolean);
+  const mergedCycleStart = cycleStartCandidates.length > 0 ? cycleStartCandidates.slice().sort((left, right) => left.localeCompare(right))[0] : now;
+  db.prepare(
+    `UPDATE provider_reliability_metrics
+     SET current_streak = ?,
+         longest_streak = ?,
+         total_hires = ?,
+         repeat_hires = ?,
+         feedback_count = ?,
+         feedback_sum = ?,
+         availability_checks = ?,
+         availability_hits = ?,
+         cycle_start = ?,
+         updated_at = ?
+     WHERE owner = ?`
+  ).run(
+    Math.max(oldRow.current_streak, newRow.current_streak),
+    Math.max(oldRow.longest_streak, newRow.longest_streak),
+    oldRow.total_hires + newRow.total_hires,
+    oldRow.repeat_hires + newRow.repeat_hires,
+    oldRow.feedback_count + newRow.feedback_count,
+    oldRow.feedback_sum + newRow.feedback_sum,
+    oldRow.availability_checks + newRow.availability_checks,
+    oldRow.availability_hits + newRow.availability_hits,
+    mergedCycleStart,
+    now,
+    newOwner
+  );
+  db.prepare("DELETE FROM provider_reliability_metrics WHERE owner = ?").run(oldOwner);
+}
+function migrateCreditOwnerData(db, oldOwner, newOwner) {
+  if (!oldOwner || !newOwner || oldOwner === newOwner) return;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.transaction(() => {
+    mergeBalanceRows(db, oldOwner, newOwner, now);
+    if (tableExists(db, "credit_transactions")) {
+      db.prepare("UPDATE credit_transactions SET owner = ? WHERE owner = ?").run(newOwner, oldOwner);
+    }
+    if (tableExists(db, "credit_escrow")) {
+      db.prepare("UPDATE credit_escrow SET owner = ? WHERE owner = ?").run(newOwner, oldOwner);
+    }
+    mergeProviderRegistryRows(db, oldOwner, newOwner);
+    if (tableExists(db, "demand_vouchers")) {
+      db.prepare("UPDATE demand_vouchers SET owner = ? WHERE owner = ?").run(newOwner, oldOwner);
+    }
+    mergeReliabilityRows(db, oldOwner, newOwner, now);
+  })();
+}
+function canonicalizeCreditOwner(db, owner) {
+  if (!owner || RESERVED_OWNERS.has(owner)) {
+    return owner;
+  }
+  ensureAgentsTable(db);
+  const resolved = resolveCanonicalIdentity(db, owner);
+  if (!resolved.resolved) {
+    return owner;
+  }
+  const aliases = /* @__PURE__ */ new Set();
+  if (owner !== resolved.agent_id) {
+    aliases.add(owner);
+  }
+  if (resolved.legacy_owner && resolved.legacy_owner !== resolved.agent_id) {
+    aliases.add(resolved.legacy_owner);
+  }
+  for (const alias of aliases) {
+    migrateCreditOwnerData(db, alias, resolved.agent_id);
+  }
+  return resolved.agent_id;
+}
+
+// src/credit/reliability-metrics.ts
+var RELIABILITY_METRICS_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS provider_reliability_metrics (
+    owner TEXT PRIMARY KEY,
+    current_streak INTEGER NOT NULL DEFAULT 0,
+    longest_streak INTEGER NOT NULL DEFAULT 0,
+    total_hires INTEGER NOT NULL DEFAULT 0,
+    repeat_hires INTEGER NOT NULL DEFAULT 0,
+    feedback_count INTEGER NOT NULL DEFAULT 0,
+    feedback_sum REAL NOT NULL DEFAULT 0,
+    availability_checks INTEGER NOT NULL DEFAULT 0,
+    availability_hits INTEGER NOT NULL DEFAULT 0,
+    cycle_start TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+`;
+function ensureReliabilityTable(db) {
+  db.exec(RELIABILITY_METRICS_SCHEMA);
+}
+function ensureRow(db, owner) {
+  const canonicalOwner = canonicalizeCreditOwner(db, owner);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(
+    `INSERT OR IGNORE INTO provider_reliability_metrics
+     (owner, current_streak, longest_streak, total_hires, repeat_hires,
+      feedback_count, feedback_sum, availability_checks, availability_hits,
+      cycle_start, updated_at)
+     VALUES (?, 0, 0, 0, 0, 0, 0, 0, 0, ?, ?)`
+  ).run(canonicalOwner, now, now);
+}
+function recordSuccessfulHire(db, providerOwner, consumerOwner) {
+  const canonicalProviderOwner = canonicalizeCreditOwner(db, providerOwner);
+  const canonicalConsumerOwner = canonicalizeCreditOwner(db, consumerOwner);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  ensureRow(db, canonicalProviderOwner);
+  const isRepeat = db.prepare(
+    `SELECT COUNT(*) as cnt FROM credit_transactions
+     WHERE owner = ? AND reason = 'settlement'
+     AND reference_id IN (
+       SELECT id FROM credit_escrow WHERE owner = ?
+     )`
+  ).get(canonicalProviderOwner, canonicalConsumerOwner);
+  const repeatIncrement = (isRepeat?.cnt ?? 0) > 0 ? 1 : 0;
+  db.prepare(
+    `UPDATE provider_reliability_metrics
+     SET current_streak = current_streak + 1,
+         longest_streak = MAX(longest_streak, current_streak + 1),
+         total_hires = total_hires + 1,
+         repeat_hires = repeat_hires + ?,
+         updated_at = ?
+     WHERE owner = ?`
+  ).run(repeatIncrement, now, canonicalProviderOwner);
+}
+function recordQualityFailure(db, providerOwner) {
+  const canonicalProviderOwner = canonicalizeCreditOwner(db, providerOwner);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  ensureRow(db, canonicalProviderOwner);
+  db.prepare(
+    `UPDATE provider_reliability_metrics
+     SET current_streak = 0, updated_at = ?
+     WHERE owner = ?`
+  ).run(now, canonicalProviderOwner);
+}
+function recordFeedback(db, providerOwner, score) {
+  const canonicalProviderOwner = canonicalizeCreditOwner(db, providerOwner);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  ensureRow(db, canonicalProviderOwner);
+  db.prepare(
+    `UPDATE provider_reliability_metrics
+     SET feedback_count = feedback_count + 1,
+         feedback_sum = feedback_sum + ?,
+         updated_at = ?
+     WHERE owner = ?`
+  ).run(score, now, canonicalProviderOwner);
+}
+function recordAvailabilityCheck(db, providerOwner, wasAvailable) {
+  const canonicalProviderOwner = canonicalizeCreditOwner(db, providerOwner);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  ensureRow(db, canonicalProviderOwner);
+  db.prepare(
+    `UPDATE provider_reliability_metrics
+     SET availability_checks = availability_checks + 1,
+         availability_hits = availability_hits + ?,
+         updated_at = ?
+     WHERE owner = ?`
+  ).run(wasAvailable ? 1 : 0, now, canonicalProviderOwner);
+}
+function getReliabilityMetrics(db, owner) {
+  const canonicalOwner = canonicalizeCreditOwner(db, owner);
+  const row = db.prepare(
+    `SELECT current_streak, longest_streak, total_hires, repeat_hires,
+            feedback_count, feedback_sum, availability_checks, availability_hits
+     FROM provider_reliability_metrics WHERE owner = ?`
+  ).get(canonicalOwner);
+  if (!row) return null;
+  return {
+    current_streak: row.current_streak,
+    longest_streak: row.longest_streak,
+    total_hires: row.total_hires,
+    repeat_hires: row.repeat_hires,
+    repeat_hire_rate: row.total_hires > 0 ? row.repeat_hires / row.total_hires : 0,
+    avg_feedback_score: row.feedback_count > 0 ? row.feedback_sum / row.feedback_count : 0,
+    availability_rate: row.availability_checks > 0 ? row.availability_hits / row.availability_checks : 0
+  };
+}
+
+export {
+  migrateCreditOwnerData,
+  canonicalizeCreditOwner,
+  RELIABILITY_METRICS_SCHEMA,
+  ensureReliabilityTable,
+  recordSuccessfulHire,
+  recordQualityFailure,
+  recordFeedback,
+  recordAvailabilityCheck,
+  getReliabilityMetrics
+};

package/dist/{chunk-MWOXW7JQ.js → chunk-VJ7XBEY6.js}

@@ -4,13 +4,16 @@ import {
   decompose,
   matchSubTasks,
   orchestrate
-} from "./chunk-QCGIG7WW.js";
+} from "./chunk-7IQE34QK.js";
 import {
   BudgetManager
-} from "./chunk-QHZGOG3O.js";
+} from "./chunk-D242QZCR.js";
 import {
   openCreditDb
-} from "./chunk-RYISHSHB.js";
+} from "./chunk-F3KIEVJ2.js";
+import {
+  RelayClient
+} from "./chunk-NX27AFPA.js";
 import {
   loadPeers
 } from "./chunk-5AH3CMOX.js";
@@ -18,11 +21,9 @@ import {
   loadConfig
 } from "./chunk-75OC6E4F.js";
 import {
-  RelayClient
-} from "./chunk-Z4MCGKTL.js";
-import {
+  listCards,
   openDatabase
-} from "./chunk-S3V6R3EN.js";
+} from "./chunk-5AIYALBX.js";
 
 // src/cli/conduct.ts
 async function conductAction(task, opts) {
@@ -81,17 +82,24 @@ async function conductAction(task, opts) {
     matchResults.map((m) => [m.subtask_id, m])
   );
   const resolveAgentUrl = (owner) => {
-    const peer = peers.find((p) => p.name.toLowerCase() === owner.toLowerCase());
-    if (peer) {
-      const execDb = openDatabase(config.db_path);
-      try {
-        const stmt = execDb.prepare("SELECT id FROM capability_cards WHERE owner = ? LIMIT 1");
-        const row = stmt.get(owner);
-        return { url: peer.url, cardId: row?.id ?? owner };
-      } finally {
-        execDb.close();
+    const execDb = openDatabase(config.db_path);
+    let matchingCards;
+    try {
+      matchingCards = listCards(execDb, owner);
+    } finally {
+      execDb.close();
+    }
+    const candidateNames = /* @__PURE__ */ new Set([owner.toLowerCase()]);
+    for (const card of matchingCards) {
+      candidateNames.add(card.owner.toLowerCase());
+      if (typeof card.agent_id === "string" && card.agent_id.length > 0) {
+        candidateNames.add(card.agent_id.toLowerCase());
       }
     }
+    const peer = peers.find((p) => candidateNames.has(p.name.toLowerCase()));
+    if (peer) {
+      return { url: peer.url, cardId: matchingCards[0]?.id ?? owner };
+    }
     if (config.registry) {
       let cardId = owner;
       for (const m of matchMap.values()) {

package/dist/chunk-WTHMHNKC.js

@@ -0,0 +1,129 @@
+import {
+  AgentBnBError
+} from "./chunk-I7KWA7OB.js";
+
+// src/identity/agent-identity.ts
+var AGENTS_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS agents (
+    agent_id TEXT PRIMARY KEY,
+    display_name TEXT NOT NULL,
+    public_key TEXT NOT NULL,
+    operator_id TEXT,
+    server_id TEXT,
+    legacy_owner TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_agents_operator ON agents(operator_id);
+  CREATE INDEX IF NOT EXISTS idx_agents_legacy_owner ON agents(legacy_owner);
+`;
+function ensureAgentsTable(db) {
+  db.exec(AGENTS_SCHEMA);
+}
+function createAgentRecord(db, agent) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const record = {
+    agent_id: agent.agent_id,
+    display_name: agent.display_name,
+    public_key: agent.public_key,
+    operator_id: agent.operator_id ?? null,
+    server_id: agent.server_id ?? null,
+    legacy_owner: agent.legacy_owner ?? null,
+    created_at: now,
+    updated_at: now
+  };
+  const result = db.prepare(
+    `INSERT OR IGNORE INTO agents
+       (agent_id, display_name, public_key, operator_id, server_id, legacy_owner, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    record.agent_id,
+    record.display_name,
+    record.public_key,
+    record.operator_id,
+    record.server_id,
+    record.legacy_owner,
+    record.created_at,
+    record.updated_at
+  );
+  if (result.changes === 0) {
+    throw new AgentBnBError(
+      "AGENT_EXISTS",
+      `Agent ${agent.agent_id} already exists`
+    );
+  }
+  return record;
+}
+function lookupAgent(db, agentId) {
+  return db.prepare("SELECT * FROM agents WHERE agent_id = ?").get(agentId) ?? null;
+}
+function lookupAgentByOwner(db, owner) {
+  return db.prepare("SELECT * FROM agents WHERE legacy_owner = ?").get(owner) ?? null;
+}
+function updateAgentRecord(db, agentId, updates) {
+  const fields = [];
+  const values = [];
+  if (updates.display_name !== void 0) {
+    fields.push("display_name = ?");
+    values.push(updates.display_name);
+  }
+  if (updates.operator_id !== void 0) {
+    fields.push("operator_id = ?");
+    values.push(updates.operator_id);
+  }
+  if (updates.server_id !== void 0) {
+    fields.push("server_id = ?");
+    values.push(updates.server_id);
+  }
+  if (updates.legacy_owner !== void 0) {
+    fields.push("legacy_owner = ?");
+    values.push(updates.legacy_owner);
+  }
+  if (fields.length === 0) return;
+  fields.push("updated_at = ?");
+  values.push((/* @__PURE__ */ new Date()).toISOString());
+  values.push(agentId);
+  const result = db.prepare(`UPDATE agents SET ${fields.join(", ")} WHERE agent_id = ?`).run(...values);
+  if (result.changes === 0) {
+    throw new AgentBnBError("AGENT_NOT_FOUND", `Agent ${agentId} not found`);
+  }
+}
+function resolveCanonicalIdentity(db, identifier) {
+  ensureAgentsTable(db);
+  if (/^[a-f0-9]{16}$/.test(identifier)) {
+    const byAgentId = lookupAgent(db, identifier);
+    if (byAgentId) {
+      return {
+        agent_id: byAgentId.agent_id,
+        legacy_owner: byAgentId.legacy_owner,
+        resolved: true,
+        source: "agent_id"
+      };
+    }
+  }
+  const byOwner = lookupAgentByOwner(db, identifier);
+  if (byOwner) {
+    return {
+      agent_id: byOwner.agent_id,
+      legacy_owner: byOwner.legacy_owner,
+      resolved: true,
+      source: "legacy_owner"
+    };
+  }
+  return {
+    agent_id: identifier,
+    legacy_owner: null,
+    resolved: false,
+    source: "unresolved"
+  };
+}
+
+export {
+  ensureAgentsTable,
+  createAgentRecord,
+  lookupAgent,
+  lookupAgentByOwner,
+  updateAgentRecord,
+  resolveCanonicalIdentity
+};

package/dist/{chunk-OCSU2S6W.js → chunk-WX3GZVFG.js}

@@ -29,7 +29,8 @@ var CapabilityDeclarationSchema = {
   description: z.string().optional(),
   capability_types: z.array(z.string()).optional(),
   requires_capabilities: z.array(z.string()).optional(),
-  visibility: z.enum(["public", "private"]).optional()
+  visibility: z.enum(["public", "private"]).optional(),
+  expected_duration_ms: z.number().positive().optional()
 };
 var ApiSkillConfigSchema = z.object({
   id: z.string().min(1),

package/dist/{chunk-CKOOVZOI.js → chunk-YKMBFQC2.js}

@@ -1,19 +1,33 @@
 import {
   signEscrowReceipt
-} from "./chunk-EJKW57ZV.js";
+} from "./chunk-GIEJVKZZ.js";
 import {
   AgentBnBError
-} from "./chunk-WVY2W7AA.js";
+} from "./chunk-I7KWA7OB.js";
 
 // src/gateway/client.ts
 import { randomUUID } from "crypto";
 import { Agent } from "undici";
+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) {
@@ -28,7 +42,17 @@ function buildGatewayAuthHeaders(payload, token, identity) {
   return headers;
 }
 async function requestCapability(opts) {
-  const { gatewayUrl, token, cardId, params = {}, timeoutMs = 3e5, escrowReceipt, identity } = 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",
@@ -80,11 +104,13 @@ async function requestCapabilityBatch(gatewayUrl, token, items, opts = {}) {
       params: item.params,
       escrowReceipt: item.escrowReceipt,
       timeoutMs: opts.timeoutMs,
+      timeoutHint: opts.timeoutHint,
       identity: opts.identity
     });
     return /* @__PURE__ */ new Map([[item.id, result]]);
   }
-  const { timeoutMs = 3e5, identity } = opts;
+  const { timeoutMs: timeoutOverrideMs, timeoutHint, identity } = opts;
+  const timeoutMs = timeoutOverrideMs ?? deriveRequestTimeoutMs(timeoutHint);
   const batchPayload = items.map((item) => ({
     jsonrpc: "2.0",
     id: item.id,
@@ -129,15 +155,17 @@ async function requestCapabilityBatch(gatewayUrl, token, items, opts = {}) {
   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: opts.timeoutMs
+      timeoutMs
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -152,6 +180,10 @@ async function requestViaRelay(relay, opts) {
 }
 
 export {
+  REQUEST_TIMEOUT_FALLBACK_MS,
+  REQUEST_TIMEOUT_GRACE_MS,
+  REQUEST_TIMEOUT_EXPECTED_MULTIPLIER,
+  deriveRequestTimeoutMs,
   requestCapability,
   requestCapabilityBatch,
   requestViaRelay