agentbnb 8.2.3 → 8.3.1

package/dist/{chunk-DYQOFGGI.js → chunk-RVBW2QXU.js}

@@ -2,7 +2,10 @@ import {
   requestCapability,
   requestCapabilityBatch,
   requestViaRelay
-} from "./chunk-CKOOVZOI.js";
+} from "./chunk-R4F4XII4.js";
+import {
+  RelayClient
+} from "./chunk-4NFJ3VYZ.js";
 import {
   findPeer
 } from "./chunk-HLUEOLSZ.js";
@@ -14,10 +17,13 @@ import {
   resolveTargetCapability,
   searchCards,
   settleEscrow
-} from "./chunk-MCED4GDW.js";
+} from "./chunk-NQANA6WH.js";
+import {
+  resolveCanonicalIdentity
+} from "./chunk-EE3V3DXK.js";
 import {
   AgentBnBError
-} from "./chunk-WVY2W7AA.js";
+} from "./chunk-I7KWA7OB.js";
 
 // src/conductor/decomposition-validator.ts
 function validateAndNormalizeSubtasks(raw, context) {
@@ -262,11 +268,67 @@ function decompose(task, _availableCapabilities) {
   return [];
 }
 
-// src/autonomy/auto-request.ts
-import { randomUUID as randomUUID4 } from "crypto";
+// src/gateway/relay-dispatch.ts
+import { randomUUID as randomUUID2 } from "crypto";
+async function requestViaTemporaryRelay(opts) {
+  const {
+    registryUrl,
+    owner,
+    token,
+    targetOwner,
+    targetAgentId,
+    cardId,
+    skillId,
+    params,
+    timeoutMs = 3e5
+  } = opts;
+  const requesterId = `${owner}:req:${randomUUID2()}`;
+  const relay = new RelayClient({
+    registryUrl,
+    owner: requesterId,
+    token,
+    card: {
+      spec_version: "1.0",
+      id: randomUUID2(),
+      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/autonomy/tiers.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 var DEFAULT_AUTONOMY_CONFIG = {
   tier1_max_credits: 0,
   tier2_max_credits: 0
@@ -287,7 +349,7 @@ function insertAuditEvent(db, event) {
     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
   stmt.run(
-    randomUUID2(),
+    randomUUID3(),
     cardId,
     "autonomy-audit",
     "self",
@@ -302,9 +364,9 @@ function insertAuditEvent(db, event) {
 }
 
 // src/autonomy/pending-requests.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 function createPendingRequest(db, opts) {
-  const id = randomUUID3();
+  const id = randomUUID4();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const paramsJson = opts.params !== void 0 ? JSON.stringify(opts.params) : null;
   db.prepare(`
@@ -353,8 +415,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) {
@@ -423,6 +494,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 {
@@ -464,7 +543,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,
@@ -473,7 +552,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" };
       }
@@ -481,7 +560,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" };
       }
@@ -532,9 +611,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) {
@@ -550,39 +695,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:${randomUUID4()}`;
-        const { RelayClient } = await import("./websocket-client-4Z5P54RU.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: randomUUID4(),
-            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) {
@@ -975,6 +1096,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) {
@@ -996,6 +1118,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;
@@ -1069,7 +1197,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);
@@ -1093,7 +1221,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 };
@@ -1107,7 +1235,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 }];
@@ -1120,7 +1248,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 }];
@@ -1155,6 +1283,7 @@ export {
   interpolateObject,
   validateAndNormalizeSubtasks,
   decompose,
+  requestViaTemporaryRelay,
   DEFAULT_AUTONOMY_CONFIG,
   getAutonomyTier,
   insertAuditEvent,

package/dist/{chunk-CQFBNTGT.js → chunk-S7DZHKCG.js}

@@ -1,10 +1,13 @@
 import {
   fetchRemoteCards,
   searchCards
-} from "./chunk-RYISHSHB.js";
+} from "./chunk-F3KIEVJ2.js";
 import {
   getCard
-} from "./chunk-S3V6R3EN.js";
+} from "./chunk-5AIYALBX.js";
+import {
+  resolveCanonicalIdentity
+} from "./chunk-WTHMHNKC.js";
 
 // src/gateway/resolve-target-capability.ts
 function canQueryLocalDb(db) {
@@ -39,15 +42,25 @@ function pickSkill(card, queryOrId) {
   if ((scored[0]?.score ?? 0) > 0) return scored[0]?.skill;
   return skills[0];
 }
-function toResolved(card, queryOrId, source) {
+function resolveCardAgentId(card, registryDb) {
+  if (typeof card.agent_id === "string" && card.agent_id.length > 0) {
+    return card.agent_id;
+  }
+  if (!canQueryLocalDb(registryDb)) return void 0;
+  const resolved = resolveCanonicalIdentity(registryDb, card.owner);
+  return resolved.resolved ? resolved.agent_id : void 0;
+}
+function toResolved(card, queryOrId, source, registryDb) {
   const skill = pickSkill(card, queryOrId);
   const gatewayUrl = getGatewayUrl(card);
   const viaRelay = source === "local" ? false : gatewayUrl.length === 0;
   const resolvedSource = viaRelay ? "relay" : source;
+  const agentId = resolveCardAgentId(card, registryDb);
   return {
     cardId: card.id,
     skillId: skill?.id,
     owner: card.owner,
+    ...agentId ? { agent_id: agentId } : {},
     gateway_url: gatewayUrl,
     via_relay: viaRelay,
     credits_per_call: skill?.pricing.credits_per_call ?? card.pricing.credits_per_call,
@@ -74,7 +87,7 @@ function findRemoteBySkillId(cards, skillId) {
   return null;
 }
 function looksLikeCardId(value) {
-  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+  return value.startsWith("card-") || /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
 }
 async function resolveTargetCapability(queryOrId, options) {
   const { registryDb, registryUrl, onlineOnly = true } = options;
@@ -83,15 +96,15 @@ async function resolveTargetCapability(queryOrId, options) {
   if (canQueryLocalDb(registryDb)) {
     const byCardId = getCard(registryDb, needle);
     if (byCardId && (!onlineOnly || isOnline(byCardId))) {
-      return toResolved(byCardId, needle, "local");
+      return toResolved(byCardId, needle, "local", registryDb);
     }
     const bySkillId = findLocalBySkillId(registryDb, needle, onlineOnly);
     if (bySkillId) {
-      return toResolved(bySkillId, needle, "local");
+      return toResolved(bySkillId, needle, "local", registryDb);
     }
     const localMatches = searchCards(registryDb, needle, { online: onlineOnly ? true : void 0 });
     if (localMatches.length > 0) {
-      return toResolved(localMatches[0], needle, "local");
+      return toResolved(localMatches[0], needle, "local", registryDb);
     }
   }
   if (!registryUrl) return null;
@@ -101,7 +114,7 @@ async function resolveTargetCapability(queryOrId, options) {
       if (cardResp.ok) {
         const remoteCard = await cardResp.json();
         if (!onlineOnly || isOnline(remoteCard)) {
-          return toResolved(remoteCard, needle, "remote");
+          return toResolved(remoteCard, needle, "remote", registryDb);
         }
       }
     } catch {
@@ -114,8 +127,8 @@ async function resolveTargetCapability(queryOrId, options) {
     });
     if (remoteMatches.length > 0) {
       const exactSkill = findRemoteBySkillId(remoteMatches, needle);
-      if (exactSkill) return toResolved(exactSkill, needle, "remote");
-      return toResolved(remoteMatches[0], needle, "remote");
+      if (exactSkill) return toResolved(exactSkill, needle, "remote", registryDb);
+      return toResolved(remoteMatches[0], needle, "remote", registryDb);
     }
   } catch {
   }
@@ -124,7 +137,7 @@ async function resolveTargetCapability(queryOrId, options) {
       ...onlineOnly ? { online: true } : {}
     });
     const exactSkill = findRemoteBySkillId(onlineCards, needle);
-    if (exactSkill) return toResolved(exactSkill, needle, "relay");
+    if (exactSkill) return toResolved(exactSkill, needle, "relay", registryDb);
     const tokens = needle.toLowerCase().split(/\s+/).filter((t) => t.length > 0);
     const fuzzy = onlineCards.find((card) => {
       const text = [
@@ -134,7 +147,7 @@ async function resolveTargetCapability(queryOrId, options) {
       ].join(" ").toLowerCase();
       return tokens.some((token) => text.includes(token));
     });
-    if (fuzzy) return toResolved(fuzzy, needle, "relay");
+    if (fuzzy) return toResolved(fuzzy, needle, "relay", registryDb);
   } catch {
   }
   return null;