@ouro.bot/cli 0.1.0-alpha.989 → 0.1.0-alpha.990

package/dist/repertoire/tools-a2a.js

@@ -44,6 +44,7 @@ const client_1 = require("../a2a/client");
 const onboarding_1 = require("../a2a/onboarding");
 const identity_2 = require("../a2a/identity");
 const transport_1 = require("../a2a/transport");
+const relay_contacts_1 = require("../a2a/relay-contacts");
 const delegation_stores_1 = require("../a2a/delegation-stores");
 const mission_result_wire_1 = require("../a2a/mission-result-wire");
 const outboundTaskTokens = new Map();
@@ -190,9 +191,10 @@ async function sealEnvelopeToPeer(input) {
         message: "sealing outbound A2A envelope to a DID-keyed peer",
         meta: { selfDid: input.self.did, peerDid: input.did, rung: reachability.rung, friendsKind: input.friendsKind },
     });
+    const relay = relayTransportFor(input);
     const result = await (0, a2a_client_1.sendShare)({
         sodium: input.sodium,
-        transport: (0, transport_1.makeA2ATransport)(),
+        transport: relay.transport,
         fromIdentity: input.self,
         toPeer: { a2a: input.peer.agentMeta?.a2a },
         recipientDid: input.did,
@@ -204,6 +206,36 @@ async function sealEnvelopeToPeer(input) {
     if (!result.ok) {
         throw new Error(`sealed send failed (${result.reason})`);
     }
+    return relay.delivered();
+}
+/**
+ * The transport for one send to a DID-keyed peer: direct first, then the relay contact the peer shared (if cached). A
+ * relay that refuses the contact marks it stale. After a direct delivery, the peer is online, so its contact is
+ * refreshed in the background when it is missing, stale or a day old.
+ */
+function relayTransportFor(input) {
+    const cached = (0, relay_contacts_1.readRelayContact)(input.agentRoot, input.did);
+    let delivery = { rung: "direct", directMayHaveArrived: false };
+    const transport = (0, transport_1.makeA2ATransport)({
+        ...(cached?.contact ? { relayContact: cached.contact } : {}),
+        onRelayContactRefused: () => (0, relay_contacts_1.markRelayContactStale)(input.agentRoot, input.did),
+        onDelivered: (rung, detail) => {
+            delivery = { rung, directMayHaveArrived: detail?.directMayHaveArrived ?? false };
+            const endpointUrl = input.peer.agentMeta?.a2a?.endpointUrl;
+            if (rung !== "direct" || !endpointUrl || !(0, relay_contacts_1.relayContactNeedsRefresh)(cached, Date.now()))
+                return;
+            const cardUrl = input.peer.agentMeta?.a2a?.cardUrl ?? new URL("/.well-known/agent-card.json", endpointUrl).toString();
+            void (0, relay_contacts_1.refreshRelayContact)({ agentRoot: input.agentRoot, peerDid: input.did, cardUrl, identity: input.self });
+        },
+    });
+    return { transport, delivered: () => delivery };
+}
+/** The tool wording for a sealed delivery. */
+function deliveryText(peerName, did, delivery, what = "sealed message") {
+    if (delivery.rung === "direct")
+        return `${what} delivered to ${peerName} (${did}) over the direct rung.`;
+    const head = delivery.directMayHaveArrived ? `direct delivery to ${peerName} (${did}) failed and the ${what} may have arrived; a copy` : `${peerName} (${did}) is not reachable directly; the ${what}`;
+    return `${head} is queued at ${peerName}'s relay and is delivered when ${peerName} comes back online.`;
 }
 /**
  * Seal an outbound free-text message to a DID-keyed peer over the `direct` rung. The
@@ -221,8 +253,8 @@ async function sealAndSendToPeer(input) {
         note: input.message,
         issuedAt: new Date().toISOString(),
     };
-    await sealEnvelopeToPeer({
-        self: { did: self.did, keyId: self.keyId, ed25519Priv: self.ed25519Priv },
+    return await sealEnvelopeToPeer({
+        agentRoot: input.agentRoot, self,
         sodium, peer: input.peer, did: input.did, envelope, friendsKind: "coordination",
     });
 }
@@ -389,14 +421,17 @@ exports.a2aToolDefinitions = [
             const did = peerDid(peer);
             if (did) {
                 try {
-                    await sealAndSendToPeer({
-                        /* v8 ignore next -- in-turn a2a_send_message always carries a bundle agentRoot; the ambient-name fallback is defensive @preserve */
-                        agentName: agentNameFromRoot(ctx?.agentRoot) ?? "ouro-agent",
+                    /* v8 ignore next -- in-turn a2a_send_message always carries a bundle agentRoot; the ambient-name fallback is defensive @preserve */
+                    const agentName = agentNameFromRoot(ctx?.agentRoot) ?? "ouro-agent";
+                    const delivery = await sealAndSendToPeer({
+                        agentName,
+                        /* v8 ignore next -- same defensive ambient fallback as agentName @preserve */
+                        agentRoot: ctx?.agentRoot ?? (0, identity_1.getAgentRoot)(agentName),
                         peer,
                         did,
                         message: args.message,
                     });
-                    return `sealed message delivered to ${peer.name} (${did}) over the direct rung.`;
+                    return deliveryText(peer.name, did, delivery);
                 }
                 catch (error) {
                     return `A2A sealed send error: ${error instanceof Error ? error.message : /* v8 ignore next -- defensive non-Error transport failures @preserve */ String(error)}`;
@@ -534,8 +569,10 @@ exports.a2aToolDefinitions = [
                 }
                 const requestId = prepared.envelope.task?.requestId;
                 // Seal + send the coordination envelope to the peer over direct.
-                await sealEnvelopeToPeer({
-                    self: { did: self.did, keyId: self.keyId, ed25519Priv: self.ed25519Priv },
+                const delivery = await sealEnvelopeToPeer({
+                    /* v8 ignore next -- in-turn coordinate always carries a bundle agentRoot; the ambient fallback is defensive @preserve */
+                    agentRoot: ctx?.agentRoot ?? (0, identity_1.getAgentRoot)(agentName),
+                    self,
                     sodium, peer, did,
                     envelope: prepared.envelope,
                     friendsKind: "coordination",
@@ -546,7 +583,8 @@ exports.a2aToolDefinitions = [
                     message: "coordination delegated + sealed to peer",
                     meta: { tool: "coordinate", peerDid: did, missionKey: args.mission_key, requestId },
                 });
-                return `coordinated: delegated "${args.task_summary}" to ${peer.name} on mission ${args.mission_key} (requestId ${requestId}).`;
+                const queued = delivery.rung === "relay" ? ` ${deliveryText(peer.name, did, delivery, "delegation")}` : "";
+                return `coordinated: delegated "${args.task_summary}" to ${peer.name} on mission ${args.mission_key} (requestId ${requestId}).${queued}`;
             }
             catch (error) {
                 return `coordinate error: ${error instanceof Error ? error.message : /* v8 ignore next -- defensive non-Error failures @preserve */ String(error)}`;
@@ -686,8 +724,13 @@ exports.a2aToolDefinitions = [
                     message: "delivering sealed mission result over the direct rung",
                     meta: { selfDid: self.did, toDid: delegatorDid, requestId: args.request_id },
                 });
-                await (0, client_1.postA2AMessageEnvelope)({ endpointUrl, message });
-                return `result sent to ${delegator.name} (${delegatorDid}) for requestId ${args.request_id}.`;
+                /* v8 ignore next -- in-turn send_result always carries a bundle agentRoot; the ambient fallback is defensive @preserve */
+                const relay = relayTransportFor({ agentRoot: ctx?.agentRoot ?? (0, identity_1.getAgentRoot)(agentName), self, peer: delegator, did: delegatorDid });
+                await relay.transport.send({ rung: "direct", address: endpointUrl }, message);
+                const delivery = relay.delivered();
+                return delivery.rung === "direct"
+                    ? `result sent to ${delegator.name} (${delegatorDid}) for requestId ${args.request_id}.`
+                    : `${deliveryText(delegator.name, delegatorDid, delivery, "result")} (requestId ${args.request_id})`;
             }
             catch (error) {
                 return `send_result error: ${error instanceof Error ? error.message : /* v8 ignore next -- defensive non-Error failures @preserve */ String(error)}`;

package/dist/senses/a2a-entry.js

@@ -62,8 +62,9 @@ Promise.all([
     Promise.resolve().then(() => __importStar(require("../heart/machine-identity"))),
     Promise.resolve().then(() => __importStar(require("@ouro.bot/friends/a2a-client"))),
     Promise.resolve().then(() => __importStar(require("../a2a/escalation-wiring"))),
+    Promise.resolve().then(() => __importStar(require("../a2a/relay-config-vault"))),
 ])
-    .then(async ([{ startA2AServer }, { loadOrMintA2AIdentity, readStoredA2ASeed, publishOwnA2ADid }, { waitForRuntimeCredentialBootstrap, readMachineRuntimeCredentialConfig, refreshMachineRuntimeCredentialConfig, mergeMachineRuntimeCredentialConfig }, { loadOrCreateMachineIdentity }, { ready }, { escalationOptionsFor, sendOwnerNoticeViaTelegram },]) => {
+    .then(async ([{ startA2AServer }, { loadOrMintA2AIdentity, readStoredA2ASeed, publishOwnA2ADid }, { waitForRuntimeCredentialBootstrap, readMachineRuntimeCredentialConfig, refreshMachineRuntimeCredentialConfig, mergeMachineRuntimeCredentialConfig }, { loadOrCreateMachineIdentity }, { ready }, { escalationOptionsFor, sendOwnerNoticeViaTelegram }, { relayConfigFrom, vaultRelayConfigStore },]) => {
     const os = await Promise.resolve().then(() => __importStar(require("node:os")));
     // Wait for the daemon to deliver the machine-local runtime config (carrying the
     // a2a identity seed) into the in-memory cache before we read or mint identity.
@@ -94,6 +95,7 @@ Promise.all([
         },
     });
     publishOwnA2ADid((0, identity_1.getAgentRoot)(agentName), identity.did);
+    const relaySettings = relayConfigFrom(machineConfig);
     const rawPort = argValue("--port");
     const port = rawPort ? Number.parseInt(rawPort, 10) : undefined;
     await startA2AServer({
@@ -113,6 +115,11 @@ Promise.all([
         } : {}),
         ...escalationOptionsFor(agentName, (notice) => sendOwnerNoticeViaTelegram(agentName, notice)),
         notifyOwner: (notice) => sendOwnerNoticeViaTelegram(agentName, notice),
+        // A friends-relay inbox for messages sent while this agent is offline, when the operator set a2a.relay.url
+        // (or registrations on relays it moved away from still have to be drained and removed).
+        ...(relaySettings.url || relaySettings.previousRegistrations?.length
+            ? { relay: { config: vaultRelayConfigStore(agentName, machineId), notifyOwner: (notice) => sendOwnerNoticeViaTelegram(agentName, notice) } }
+            : {}),
         ...(argValue("--host") ? { host: argValue("--host") } : {}),
         ...(Number.isInteger(port) ? { port } : {}),
         ...(argValue("--base-url") ? { baseUrl: argValue("--base-url") } : {}),

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.989",
+  "version": "0.1.0-alpha.990",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ouro.bot/cli",
-      "version": "0.1.0-alpha.989",
+      "version": "0.1.0-alpha.990",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.78.0",
         "@azure/identity": "^4.13.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.989",
+  "version": "0.1.0-alpha.990",
   "engines": {
     "node": ">=22"
   },