agentbnb 8.2.2 → 8.3.0

package/dist/chunk-6QMDJVMS.js

@@ -0,0 +1,238 @@
+import {
+  ensureAgentsTable,
+  resolveCanonicalIdentity
+} from "./chunk-EE3V3DXK.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-LKLKYXLV.js → chunk-74LZDEDT.js}

@@ -3,22 +3,24 @@ import {
   getBalance,
   getTransactions,
   holdEscrow,
-  lookupAgent,
   migrateOwner,
   openCreditDb,
   releaseEscrow,
   settleEscrow
-} from "./chunk-RYISHSHB.js";
+} from "./chunk-F3KIEVJ2.js";
 import {
   generateKeyPair,
   loadKeyPair,
   saveKeyPair,
   signEscrowReceipt,
   verifyEscrowReceipt
-} from "./chunk-EJKW57ZV.js";
+} from "./chunk-GIEJVKZZ.js";
+import {
+  lookupAgent
+} from "./chunk-WTHMHNKC.js";
 import {
   AgentBnBError
-} from "./chunk-WVY2W7AA.js";
+} from "./chunk-I7KWA7OB.js";
 
 // src/identity/identity.ts
 import { z } from "zod";

package/dist/{chunk-GKVTD4EZ.js → chunk-77KGEDH4.js}

@@ -1,6 +1,6 @@
 import {
   AgentBnBError
-} from "./chunk-WVY2W7AA.js";
+} from "./chunk-I7KWA7OB.js";
 
 // src/autonomy/tiers.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-QCGIG7WW.js → chunk-7IQE34QK.js}

@@ -3,15 +3,15 @@ import {
 } from "./chunk-3MJT4PZG.js";
 import {
   scorePeers
-} from "./chunk-QHZGOG3O.js";
+} from "./chunk-D242QZCR.js";
 import {
   fetchRemoteCards,
   searchCards
-} from "./chunk-RYISHSHB.js";
+} from "./chunk-F3KIEVJ2.js";
 import {
   requestCapability,
   requestCapabilityBatch
-} from "./chunk-CKOOVZOI.js";
+} from "./chunk-YKMBFQC2.js";
 
 // src/conductor/decomposition-validator.ts
 function validateAndNormalizeSubtasks(raw, context) {
@@ -471,6 +471,7 @@ async function executeSingleTask(pt, gatewayToken, timeoutMs, requesterOwner, re
 async function orchestrate(opts) {
   const { subtasks, matches, gatewayToken, resolveAgentUrl, timeoutMs = 3e5, maxBudget, relayClient, requesterOwner } = opts;
   const startTime = Date.now();
+  const hardDeadline = startTime + timeoutMs;
   const teamMemberMap = /* @__PURE__ */ new Map();
   if (opts.team) {
     for (const member of opts.team.matched) {
@@ -492,6 +493,12 @@ async function orchestrate(opts) {
   const waves = computeWaves(subtasks);
   const subtaskMap = new Map(subtasks.map((s) => [s.id, s]));
   for (const wave of waves) {
+    const remainingWaveMs = hardDeadline - Date.now();
+    if (remainingWaveMs <= 0) {
+      errors.push(`Orchestration timed out after ${timeoutMs}ms`);
+      break;
+    }
+    const waveTimeoutMs = Math.max(1, Math.min(timeoutMs, remainingWaveMs));
     if (maxBudget !== void 0 && totalCredits >= maxBudget) {
       errors.push(`Budget exceeded: spent ${totalCredits} cr, max ${maxBudget} cr`);
       break;
@@ -565,7 +572,7 @@ async function orchestrate(opts) {
                 gatewayUrl,
                 gatewayToken,
                 items.map(({ _pt, ...item }) => item),
-                { timeoutMs }
+                { timeoutMs: waveTimeoutMs }
               );
               return items.map((item) => {
                 const res = batchResults.get(item.id);
@@ -589,7 +596,7 @@ async function orchestrate(opts) {
             } catch (batchErr) {
               return Promise.all(group.map(async (pt) => {
                 try {
-                  const res = await executeSingleTask(pt, gatewayToken, timeoutMs, requesterOwner, relayClient, resolveAgentUrl);
+                  const res = await executeSingleTask(pt, gatewayToken, waveTimeoutMs, requesterOwner, relayClient, resolveAgentUrl);
                   return { status: "fulfilled", value: res };
                 } catch (err) {
                   return { status: "rejected", reason: err };
@@ -603,7 +610,7 @@ async function orchestrate(opts) {
         batchPromises.push(
           (async () => {
             try {
-              const res = await executeSingleTask(pt, gatewayToken, timeoutMs, requesterOwner, relayClient, resolveAgentUrl);
+              const res = await executeSingleTask(pt, gatewayToken, waveTimeoutMs, requesterOwner, relayClient, resolveAgentUrl);
               return [{ status: "fulfilled", value: res }];
             } catch (err) {
               return [{ status: "rejected", reason: err }];
@@ -616,7 +623,7 @@ async function orchestrate(opts) {
       batchPromises.push(
         (async () => {
           try {
-            const res = await executeSingleTask(pt, gatewayToken, timeoutMs, requesterOwner, relayClient, resolveAgentUrl);
+            const res = await executeSingleTask(pt, gatewayToken, waveTimeoutMs, requesterOwner, relayClient, resolveAgentUrl);
             return [{ status: "fulfilled", value: res }];
           } catch (err) {
             return [{ status: "rejected", reason: err }];

package/dist/{chunk-QHZGOG3O.js → chunk-D242QZCR.js}

@@ -2,10 +2,10 @@ import {
   createPendingRequest,
   getAutonomyTier,
   insertAuditEvent
-} from "./chunk-GKVTD4EZ.js";
+} from "./chunk-77KGEDH4.js";
 import {
   resolveTargetCapability
-} from "./chunk-CQFBNTGT.js";
+} from "./chunk-S7DZHKCG.js";
 import {
   fetchRemoteCards,
   getBalance,
@@ -13,14 +13,82 @@ import {
   releaseEscrow,
   searchCards,
   settleEscrow
-} from "./chunk-RYISHSHB.js";
+} from "./chunk-F3KIEVJ2.js";
+import {
+  RelayClient
+} from "./chunk-NX27AFPA.js";
 import {
   requestCapability,
   requestViaRelay
-} from "./chunk-CKOOVZOI.js";
+} from "./chunk-YKMBFQC2.js";
 import {
   findPeer
 } from "./chunk-5AH3CMOX.js";
+import {
+  resolveCanonicalIdentity
+} from "./chunk-WTHMHNKC.js";
+import {
+  AgentBnBError
+} from "./chunk-I7KWA7OB.js";
+
+// src/gateway/relay-dispatch.ts
+import { randomUUID } from "crypto";
+async function requestViaTemporaryRelay(opts) {
+  const {
+    registryUrl,
+    owner,
+    token,
+    targetOwner,
+    targetAgentId,
+    cardId,
+    skillId,
+    params,
+    timeoutMs = 3e5
+  } = opts;
+  const requesterId = `${owner}:req:${randomUUID()}`;
+  const relay = new RelayClient({
+    registryUrl,
+    owner: requesterId,
+    token,
+    card: {
+      spec_version: "1.0",
+      id: randomUUID(),
+      owner: requesterId,
+      name: requesterId,
+      description: "Temporary relay requester",
+      level: 1,
+      inputs: [],
+      outputs: [],
+      pricing: { credits_per_call: 0 },
+      availability: { online: false }
+    },
+    onRequest: async () => ({
+      error: { code: -32601, message: "Temporary relay requester does not serve capabilities" }
+    }),
+    silent: true
+  });
+  try {
+    await relay.connect();
+  } catch (err) {
+    relay.disconnect();
+    const message = err instanceof Error ? err.message : String(err);
+    throw new AgentBnBError(`Relay connection failed: ${message}`, "RELAY_UNAVAILABLE");
+  }
+  try {
+    return await requestViaRelay(relay, {
+      targetOwner,
+      targetAgentId,
+      cardId,
+      skillId,
+      params,
+      requester: owner,
+      // actual owner for credit tracking on relay server
+      timeoutMs
+    });
+  } finally {
+    relay.disconnect();
+  }
+}
 
 // src/credit/budget.ts
 var DEFAULT_BUDGET_CONFIG = {
@@ -68,7 +136,6 @@ var BudgetManager = class {
 };
 
 // src/autonomy/auto-request.ts
-import { randomUUID } from "crypto";
 function minMaxNormalize(values) {
   if (values.length === 0) return [];
   if (values.length === 1) return [1];
@@ -79,8 +146,17 @@ function minMaxNormalize(values) {
   }
   return values.map((v) => (v - min) / (max - min));
 }
-function scorePeers(candidates, selfOwner) {
-  const eligible = candidates.filter((c) => c.card.owner !== selfOwner);
+function scorePeers(candidates, selfOwner, registryDb) {
+  const selfIdentity = registryDb ? resolveCanonicalIdentity(registryDb, selfOwner) : null;
+  const eligible = candidates.filter((c) => {
+    if (c.card.owner === selfOwner) return false;
+    if (!registryDb || !selfIdentity?.resolved) return true;
+    if (typeof c.card.agent_id === "string" && c.card.agent_id.length > 0) {
+      return c.card.agent_id !== selfIdentity.agent_id;
+    }
+    const peerIdentity = resolveCanonicalIdentity(registryDb, c.card.owner);
+    return !peerIdentity.resolved || peerIdentity.agent_id !== selfIdentity.agent_id;
+  });
   if (eligible.length === 0) return [];
   const successRates = eligible.map((c) => {
     if (c.skillMetadata?.success_rate !== void 0) {
@@ -149,6 +225,14 @@ var AutoRequestor = class {
    * @returns The result of the auto-request attempt.
    */
   async requestWithAutonomy(need) {
+    const selfIdentity = resolveCanonicalIdentity(this.registryDb, this.owner);
+    const isSelfTarget = (targetOwner, targetAgentId) => {
+      if (targetOwner === this.owner) return true;
+      if (!selfIdentity.resolved) return false;
+      if (targetAgentId && targetAgentId === selfIdentity.agent_id) return true;
+      const targetOwnerIdentity = resolveCanonicalIdentity(this.registryDb, targetOwner);
+      return targetOwnerIdentity.resolved && targetOwnerIdentity.agent_id === selfIdentity.agent_id;
+    };
     let cards = searchCards(this.registryDb, need.query, { online: true });
     if (cards.length === 0 && this.registryUrl) {
       try {
@@ -190,7 +274,7 @@ var AutoRequestor = class {
         }
       }
     }
-    const scored = scorePeers(candidates, this.owner);
+    const scored = scorePeers(candidates, this.owner, this.registryDb);
     const resolverOptions = {
       registryDb: this.registryDb,
       registryUrl: this.registryUrl,
@@ -199,7 +283,7 @@ var AutoRequestor = class {
     let resolvedTarget = null;
     if (scored.length === 0) {
       resolvedTarget = await resolveTargetCapability(need.query, resolverOptions);
-      if (!resolvedTarget || resolvedTarget.owner === this.owner || resolvedTarget.credits_per_call > need.maxCostCredits) {
+      if (!resolvedTarget || isSelfTarget(resolvedTarget.owner, resolvedTarget.agent_id) || resolvedTarget.credits_per_call > need.maxCostCredits) {
         this.logFailure("auto_request_failed", "system", "none", 3, 0, "none", "No eligible peer found");
         return { status: "no_peer", reason: "No eligible peer found" };
       }
@@ -207,7 +291,7 @@ var AutoRequestor = class {
       const top = scored[0];
       const targetKey = top.skillId ?? top.card.id;
       resolvedTarget = await resolveTargetCapability(targetKey, resolverOptions) ?? await resolveTargetCapability(need.query, resolverOptions);
-      if (!resolvedTarget || resolvedTarget.owner === this.owner) {
+      if (!resolvedTarget || isSelfTarget(resolvedTarget.owner, resolvedTarget.agent_id)) {
         this.logFailure("auto_request_failed", top.card.id, top.skillId ?? "none", 3, top.cost, top.card.owner, "No eligible peer found");
         return { status: "no_peer", reason: "No eligible peer found" };
       }
@@ -258,9 +342,75 @@ var AutoRequestor = class {
       );
       return { status: "budget_blocked", reason: "Insufficient credits \u2014 reserve floor would be breached" };
     }
+    const requestParams = selectedSkillId ? { skill_id: selectedSkillId, ...need.params, requester: this.owner } : { ...need.params, requester: this.owner };
+    if (selectedViaRelay && selectedCost > 0) {
+      if (!this.registryUrl) {
+        this.logFailure(
+          "auto_request_failed",
+          selectedCardId,
+          selectedSkillId ?? "none",
+          tier,
+          selectedCost,
+          selectedPeer,
+          "Relay target found but registryUrl is not configured"
+        );
+        return { status: "no_peer", reason: "Relay target found but registryUrl is not configured" };
+      }
+      try {
+        const execResult = await requestViaTemporaryRelay({
+          registryUrl: this.registryUrl,
+          owner: this.owner,
+          token: "auto-request-token",
+          targetOwner: selectedPeer,
+          cardId: selectedCardId,
+          skillId: selectedSkillId,
+          params: requestParams
+        });
+        if (tier === 2) {
+          insertAuditEvent(this.registryDb, {
+            type: "auto_request_notify",
+            card_id: selectedCardId,
+            skill_id: selectedSkillId ?? selectedCardId,
+            tier_invoked: 2,
+            credits: selectedCost,
+            peer: selectedPeer
+          });
+        } else {
+          insertAuditEvent(this.registryDb, {
+            type: "auto_request",
+            card_id: selectedCardId,
+            skill_id: selectedSkillId ?? selectedCardId,
+            tier_invoked: 1,
+            credits: selectedCost,
+            peer: selectedPeer
+          });
+        }
+        return {
+          status: "success",
+          result: execResult,
+          peer: selectedPeer,
+          creditsSpent: selectedCost
+        };
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        this.logFailure(
+          "auto_request_failed",
+          selectedCardId,
+          selectedSkillId ?? "none",
+          tier,
+          selectedCost,
+          selectedPeer,
+          `Execution failed: ${reason}`
+        );
+        return {
+          status: "failed",
+          reason: `Execution failed: ${reason}`,
+          peer: selectedPeer
+        };
+      }
+    }
     const escrowId = holdEscrow(this.creditDb, this.owner, selectedCost, selectedCardId);
     try {
-      const requestParams = selectedSkillId ? { skill_id: selectedSkillId, ...need.params, requester: this.owner } : { ...need.params, requester: this.owner };
       let execResult;
       if (selectedViaRelay) {
         if (!this.registryUrl) {
@@ -276,39 +426,15 @@ var AutoRequestor = class {
           releaseEscrow(this.creditDb, escrowId);
           return { status: "no_peer", reason: "Relay target found but registryUrl is not configured" };
         }
-        const relayRequesterOwner = `${this.owner}:req:${randomUUID()}`;
-        const { RelayClient } = await import("./websocket-client-QOVARTRN.js");
-        const relayClient = new RelayClient({
+        execResult = await requestViaTemporaryRelay({
           registryUrl: this.registryUrl,
-          owner: relayRequesterOwner,
+          owner: this.owner,
           token: "auto-request-token",
-          card: {
-            spec_version: "1.0",
-            id: randomUUID(),
-            owner: relayRequesterOwner,
-            name: relayRequesterOwner,
-            description: "Auto-request requester",
-            level: 1,
-            inputs: [],
-            outputs: [],
-            pricing: { credits_per_call: 1 },
-            availability: { online: false }
-          },
-          onRequest: async () => ({ error: { code: -32601, message: "Auto-request relay requester does not serve capabilities" } }),
-          silent: true
+          targetOwner: selectedPeer,
+          cardId: selectedCardId,
+          skillId: selectedSkillId,
+          params: requestParams
         });
-        try {
-          await relayClient.connect();
-          execResult = await requestViaRelay(relayClient, {
-            targetOwner: selectedPeer,
-            cardId: selectedCardId,
-            skillId: selectedSkillId,
-            params: requestParams,
-            requester: this.owner
-          });
-        } finally {
-          relayClient.disconnect();
-        }
       } else {
         const peerConfig = findPeer(selectedPeer);
         if (!peerConfig) {
@@ -395,6 +521,7 @@ var AutoRequestor = class {
 };
 
 export {
+  requestViaTemporaryRelay,
   DEFAULT_BUDGET_CONFIG,
   BudgetManager,
   scorePeers,