@okxweb3/a2a-node 0.2.17 → 0.2.18

package/dist/cli.js

@@ -27018,7 +27018,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     client: {
       id: "gateway-client",
       displayName: "okx-a2a-node",
-      version: "0.2.17",
+      version: "0.2.18",
       platform: "node",
       mode: "backend",
       instanceId
@@ -27029,7 +27029,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     commands: [],
     permissions: {},
     locale: Intl.DateTimeFormat().resolvedOptions().locale || "en-US",
-    userAgent: `okx-a2a-node/${"0.2.17"}`,
+    userAgent: `okx-a2a-node/${"0.2.18"}`,
     auth: {
       ...config.token ? { token: config.token } : {},
       ...config.password ? { password: config.password } : {}
@@ -29089,7 +29089,7 @@ var init_sentry_config = __esm({
     environment = process.env.SENTRY_ENV === "dev" ? "dev" : "prod";
     SENTRY_CONFIG = {
       projectName: "okx/openclaw-okx-a2a-extension",
-      release: "0.2.17",
+      release: "0.2.18",
       environment,
       runtimeContainer: normalizeRuntimeContainer(process.env.OKX_A2A_RUNTIME_CONTAINER)
     };
@@ -40259,7 +40259,7 @@ async function exportDiagnosticLogs(options) {
     node: process.version,
     platform: process.platform,
     arch: process.arch,
-    packageVersion: true ? "0.2.17" : "unknown",
+    packageVersion: true ? "0.2.18" : "unknown",
     sensitiveContentIncluded: options.includeSensitiveContent,
     listenerAndLlmContentIncluded: true,
     credentialsAlwaysRedacted: true,
@@ -42950,7 +42950,7 @@ function createAsyncStreamProxy(stream) {
     }
   });
 }
-var import_node_bindings, import_node_bindings2, import_node_crypto9, import_types, import_node_path26, import_node_process, HistorySyncUrls, envMap, reverseEnvMap, envToString, createBackend, InboxReassignError, AccountAlreadyAssociatedError, MissingContentTypeError, SignerUnavailableError, ClientNotInitializedError, StreamFailedError, StreamInvalidRetryAttemptsError, generateInboxId, getInboxIdForIdentifier, isReaction, isReply, isText, isRemoteAttachment, isAttachment, isMultiRemoteAttachment, isTransactionReference, isGroupUpdated, isReadReceipt, isLeaveRequest, isWalletSendCalls, isIntent, isActions, isMarkdown, CodecRegistry, getContentFromDecodedMessageContent, getContentTypeFromDecodedMessageContent, DecodedMessage, AsyncStream, usableProperties, isUsableProperty, wait, DEFAULT_RETRY_DELAY, DEFAULT_RETRY_ATTEMPTS, createStream, Conversation, Dm, Group, Conversations, DebugInformation, Preferences, networkOptionKeys, hasBackend, resolveBackend$1, createClient, resolveBackend, createEphemeralIdentifier, toInboxUpdatesCountMap, Client;
+var import_node_bindings, import_node_bindings2, import_node_crypto9, import_types, import_node_path26, import_node_process, HistorySyncUrls, envMap, reverseEnvMap, envToString, createBackend, InboxReassignError, AccountAlreadyAssociatedError, MissingContentTypeError, SignerUnavailableError, ClientNotInitializedError, StreamFailedError, StreamInvalidRetryAttemptsError, generateInboxId, getInboxIdForIdentifier, isReaction, isReply, isText, isRemoteAttachment, isAttachment, isMultiRemoteAttachment, isTransactionReference, isGroupUpdated, isReadReceipt, isLeaveRequest, isWalletSendCalls, isIntent, isActions, isMarkdown, CodecRegistry, getContentFromDecodedMessageContent, getContentTypeFromDecodedMessageContent, DecodedMessage, AsyncStream, usableProperties, isUsableProperty, DEFAULT_RETRY_DELAY, DEFAULT_RETRY_ATTEMPTS, createStream, Conversation, Dm, Group, Conversations, DebugInformation, Preferences, networkOptionKeys, hasBackend, resolveBackend$1, createClient, resolveBackend, createEphemeralIdentifier, toInboxUpdatesCountMap, Client;
 var init_dist2 = __esm({
   "../../node_modules/@xmtp/node-sdk/dist/index.js"() {
     import_node_bindings = require("@xmtp/node-bindings");
@@ -43360,7 +43360,6 @@ var init_dist2 = __esm({
     isUsableProperty = (prop) => {
       return usableProperties.includes(prop);
     };
-    wait = (ms) => new Promise((resolve14) => setTimeout(resolve14, ms));
     DEFAULT_RETRY_DELAY = 6e4;
     DEFAULT_RETRY_ATTEMPTS = 10;
     createStream = async (streamFunction, streamValueMutator, options) => {
@@ -43369,82 +43368,161 @@ var init_dist2 = __esm({
         throw new StreamInvalidRetryAttemptsError();
       }
       const asyncStream = new AsyncStream();
+      let stopped = false;
+      let current;
+      let recovering = false;
+      let cancelDelay;
+      const isStopped = () => stopped;
+      const isCurrent = (native) => !stopped && current === native;
+      asyncStream.onDone = () => {
+        if (stopped) {
+          return;
+        }
+        stopped = true;
+        cancelDelay?.();
+        const native = current;
+        current = void 0;
+        native?.closer?.end();
+      };
+      const delay = (ms) => new Promise((resolve14) => {
+        const timer = setTimeout(() => {
+          cancelDelay = void 0;
+          resolve14();
+        }, ms);
+        cancelDelay = () => {
+          clearTimeout(timer);
+          cancelDelay = void 0;
+          resolve14();
+        };
+      });
+      const reportError = (error) => {
+        if (!stopped) {
+          onError?.(error);
+        }
+      };
+      const deliver = (value) => {
+        if (stopped || value === void 0) {
+          return;
+        }
+        asyncStream.push(value);
+        onValue?.(value);
+      };
       const streamCallback = (error, value) => {
+        if (stopped) {
+          return;
+        }
         if (error) {
           onError?.(error);
           return;
         }
-        if (value !== void 0) {
-          try {
-            if (streamValueMutator) {
-              const mutatedValue = streamValueMutator(value);
-              if ((0, import_types.isPromise)(mutatedValue)) {
-                void mutatedValue.then((mutatedValue2) => {
-                  if (mutatedValue2 !== void 0) {
-                    asyncStream.push(mutatedValue2);
-                    onValue?.(mutatedValue2);
-                  }
-                }).catch((error2) => {
-                  onError?.(error2);
-                });
-              } else {
-                if (mutatedValue !== void 0) {
-                  asyncStream.push(mutatedValue);
-                  onValue?.(mutatedValue);
-                }
-              }
+        if (value === void 0) {
+          return;
+        }
+        try {
+          if (streamValueMutator) {
+            const mutatedValue = streamValueMutator(value);
+            if ((0, import_types.isPromise)(mutatedValue)) {
+              void mutatedValue.then(deliver).catch(reportError);
             } else {
-              asyncStream.push(value);
-              onValue?.(value);
+              deliver(mutatedValue);
             }
-          } catch (error2) {
-            onError?.(error2);
+          } else {
+            deliver(value);
           }
+        } catch (error2) {
+          reportError(error2);
         }
       };
-      const retry2 = async (retries = retryAttempts) => {
-        if (retries === 0) {
-          void asyncStream.end();
-          onError?.(new StreamFailedError(retryAttempts));
-          return;
+      const fail = (error) => {
+        void asyncStream.end();
+        onError?.(error);
+      };
+      const open2 = async () => {
+        if (stopped) {
+          return false;
+        }
+        const native = { ready: false, closed: false };
+        current = native;
+        const closer = await streamFunction(streamCallback, () => {
+          onNativeClose(native);
+        });
+        native.closer = closer;
+        if (!isCurrent(native)) {
+          closer.end();
+          return false;
+        }
+        await closer.waitForReady();
+        if (!isCurrent(native)) {
+          closer.end();
+          return false;
         }
-        await wait(retryDelay);
-        onRetry?.(retryAttempts - retries + 1, retryAttempts);
+        if (native.closed || closer.isClosed()) {
+          closer.end();
+          return false;
+        }
+        native.ready = true;
+        return true;
+      };
+      const restart = async () => {
         try {
-          const streamCloser = await streamFunction(streamCallback, () => {
-            onFail?.();
-            void retry2();
-          });
-          await streamCloser.waitForReady();
-          asyncStream.onDone = () => {
-            streamCloser.end();
-          };
-          onRestart?.();
-        } catch (error) {
-          onError?.(error);
-          void retry2(retries - 1);
+          for (let attempt = 1; attempt <= retryAttempts; attempt++) {
+            await delay(retryDelay);
+            if (isStopped()) {
+              return;
+            }
+            onRetry?.(attempt, retryAttempts);
+            let restarted = false;
+            try {
+              restarted = await open2();
+            } catch (error) {
+              reportError(error);
+            }
+            if (isStopped()) {
+              return;
+            }
+            if (restarted) {
+              try {
+                onRestart?.();
+              } catch (error) {
+                reportError(error);
+              }
+              return;
+            }
+          }
+          fail(new StreamFailedError(retryAttempts));
+        } finally {
+          recovering = false;
         }
       };
-      const startRetry = () => {
-        if (retryOnFail) {
-          void retry2();
-        } else {
-          void asyncStream.end();
-          onError?.(new StreamFailedError(0));
+      const recover = () => {
+        if (stopped || recovering) {
+          return;
         }
+        if (!retryOnFail) {
+          fail(new StreamFailedError(0));
+          return;
+        }
+        recovering = true;
+        void restart();
       };
+      function onNativeClose(native) {
+        if (!isCurrent(native) || native.closed) {
+          return;
+        }
+        native.closed = true;
+        onFail?.();
+        if (native.ready) {
+          recover();
+        }
+      }
+      let started = false;
       try {
-        const streamCloser = await streamFunction(streamCallback, () => {
-          onFail?.();
-          startRetry();
-        });
-        await streamCloser.waitForReady();
-        asyncStream.onDone = () => {
-          streamCloser.end();
-        };
+        started = await open2();
       } catch (error) {
-        onError?.(error);
-        startRetry();
+        reportError(error);
+      }
+      if (!started) {
+        recover();
       }
       return createAsyncStreamProxy(asyncStream);
     };
@@ -45614,7 +45692,7 @@ var require_retry_promise = __commonJS({
         return true;
       }
     };
-    function wait3(ms) {
+    function wait2(ms) {
       return __awaiter(this, void 0, void 0, function() {
         return __generator(this, function(_a) {
           return [2, new Promise(function(resolve14) {
@@ -45623,7 +45701,7 @@ var require_retry_promise = __commonJS({
         });
       });
     }
-    exports2.wait = wait3;
+    exports2.wait = wait2;
     function retry2(f, config) {
       return __awaiter(this, void 0, void 0, function() {
         var effectiveConfig;
@@ -45713,7 +45791,7 @@ var require_retry_promise = __commonJS({
               return [3, 5];
             case 5:
               millisToWait = delay(i + 1, config.delay);
-              return [4, wait3(millisToWait > config.maxBackOff ? config.maxBackOff : millisToWait)];
+              return [4, wait2(millisToWait > config.maxBackOff ? config.maxBackOff : millisToWait)];
             case 6:
               _a.sent();
               if (done()) {
@@ -53587,7 +53665,7 @@ var init_withResolvers = __esm({
 });
 
 // ../../node_modules/viem/_esm/utils/promise/createBatchScheduler.js
-function createBatchScheduler({ fn, id, shouldSplitBatch, wait: wait3 = 0, sort }) {
+function createBatchScheduler({ fn, id, shouldSplitBatch, wait: wait2 = 0, sort }) {
   const exec2 = async () => {
     const scheduler = getScheduler();
     flush2();
@@ -53625,7 +53703,7 @@ function createBatchScheduler({ fn, id, shouldSplitBatch, wait: wait3 = 0, sort
         return promise;
       }
       setScheduler({ args, resolve: resolve14, reject });
-      setTimeout(exec2, wait3);
+      setTimeout(exec2, wait2);
       return promise;
     }
   };
@@ -53691,7 +53769,7 @@ var init_observe = __esm({
 });
 
 // ../../node_modules/viem/_esm/utils/wait.js
-async function wait2(time) {
+async function wait(time) {
   return new Promise((res) => setTimeout(res, time));
 }
 var init_wait = __esm({
@@ -53708,12 +53786,12 @@ function poll(fn, { emitOnBegin, initialWaitTime, interval }) {
     if (emitOnBegin)
       data = await fn({ unpoll: unwatch });
     const initialWait = await initialWaitTime?.(data) ?? interval;
-    await wait2(initialWait);
+    await wait(initialWait);
     const poll2 = async () => {
       if (!active)
         return;
       await fn({ unpoll: unwatch });
-      await wait2(interval);
+      await wait(interval);
       poll2();
     };
     poll2();
@@ -54077,7 +54155,7 @@ function withRetry(fn, { delay: delay_ = 100, retryCount = 2, shouldRetry: shoul
       const retry2 = async ({ error }) => {
         const delay = typeof delay_ === "function" ? delay_({ count, error }) : delay_;
         if (delay)
-          await wait2(delay);
+          await wait(delay);
         attemptRetry({ count: count + 1 });
       };
       try {
@@ -56542,7 +56620,7 @@ var init_transport = __esm({
 function http(url, config = {}) {
   const { batch, fetchFn, fetchOptions, key = "http", methods, name = "HTTP JSON-RPC", onFetchRequest, onFetchResponse, retryDelay, raw } = config;
   return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
-    const { batchSize = 1e3, wait: wait3 = 0 } = typeof batch === "object" ? batch : {};
+    const { batchSize = 1e3, wait: wait2 = 0 } = typeof batch === "object" ? batch : {};
     const retryCount = config.retryCount ?? retryCount_;
     const timeout = timeout_ ?? config.timeout ?? 1e4;
     const url_ = url || chain?.rpcUrls.default.http[0];
@@ -56563,7 +56641,7 @@ function http(url, config = {}) {
         const body = { method, params };
         const { schedule } = createBatchScheduler({
           id: url_,
-          wait: wait3,
+          wait: wait2,
           shouldSplitBatch(requests) {
             return requests.length > batchSize;
           },
@@ -56902,7 +56980,7 @@ var init_dist4 = __esm({
     init_accounts();
     init_chains();
     import_node_crypto10 = require("node:crypto");
-    version2 = "2.3.0";
+    version2 = "2.3.1";
     fromSelf = (message, client) => {
       return message.senderInboxId === client.inboxId;
     };
@@ -58850,6 +58928,9 @@ function replayScanBackoffWithJitterMs(consecutiveFailures, randomValue = Math.r
   const jitteredMs = Math.round(baseMs * (0.9 + boundedRandom * 0.2));
   return Math.min(REPLAY_SCAN_MAX_BACKOFF_MS, jitteredMs);
 }
+function isListenHealthy(outcome) {
+  return outcome === "started" || outcome === "retrying";
+}
 function isOfflineReplayForTrigger(trigger) {
   return trigger === "startup";
 }
@@ -58877,7 +58958,7 @@ function createOfflineReplayAddressSummary(address) {
     durationMs: 0
   };
 }
-var import_node_fs24, import_node_path28, DEFAULT_DATA_DIR, XMTP_INSTALLATION_WARNING_THRESHOLD, XMTP_INSTALLATION_NEAR_LIMIT_THRESHOLD, REPLAY_SCAN_INITIAL_BACKOFF_MS, REPLAY_SCAN_MAX_BACKOFF_MS, SENSITIVE_WORDS_LAZY_RETRY_COOLDOWN_MS, InboundReplayGate, SYSTEM_CONFIG_DEFAULTS, STREAM_RECOVERY_ALERT_THRESHOLD_MS, STREAM_RECOVERY_STABILITY_WINDOW_MS, REPLAY_GATE_DRAIN_MAX_ATTEMPTS, REPLAY_GATE_DRAIN_RETRY_DELAY_MS, SEMVER_RE, isRecord5, isPositiveNumber, SYSTEM_CONFIG_VALIDATORS, XmtpService;
+var import_node_fs24, import_node_path28, DEFAULT_DATA_DIR, XMTP_INSTALLATION_WARNING_THRESHOLD, XMTP_INSTALLATION_NEAR_LIMIT_THRESHOLD, REPLAY_SCAN_INITIAL_BACKOFF_MS, REPLAY_SCAN_MAX_BACKOFF_MS, SENSITIVE_WORDS_LAZY_RETRY_COOLDOWN_MS, InboundReplayGate, SYSTEM_CONFIG_DEFAULTS, STREAM_RECOVERY_ALERT_THRESHOLD_MS, STREAM_RECOVERY_STABILITY_WINDOW_MS, REPLAY_GATE_DRAIN_MAX_ATTEMPTS, REPLAY_GATE_DRAIN_RETRY_DELAY_MS, SEMVER_RE, isRecord5, isPositiveNumber, SYSTEM_CONFIG_VALIDATORS, XmtpClientCreateBlockedError, XmtpService;
 var init_xmtp_sdk = __esm({
   "../core/src/xmtp-sdk/index.ts"() {
     "use strict";
@@ -59009,6 +59090,18 @@ var init_xmtp_sdk = __esm({
       minAvailablePluginVersion: (value) => typeof value === "string",
       extConfig: (value) => isRecord5(value) && (value.tips === void 0 || isRecord5(value.tips) && Object.values(value.tips).every((item) => typeof item === "string"))
     };
+    XmtpClientCreateBlockedError = class extends Error {
+      reason;
+      address;
+      agentId;
+      constructor(reason, address, agentId) {
+        super(`xmtp client create blocked (${reason})`);
+        this.name = "XmtpClientCreateBlockedError";
+        this.reason = reason;
+        this.address = address;
+        this.agentId = agentId;
+      }
+    };
     XmtpService = class _XmtpService {
       static instance = null;
       env = process.env.XMTP_ENV ?? "production";
@@ -59046,6 +59139,25 @@ var init_xmtp_sdk = __esm({
       streamRecoverySetTimeout = (callback, delayMs) => setTimeout(callback, delayMs);
       streamRecoveryClearTimeout = (timer) => clearTimeout(timer);
       streamStartSetTimeout = (callback, delayMs) => setTimeout(callback, delayMs);
+      xmtpAgentFactory = createAgentWithInstallationPrune;
+      // Old clients whose close() was not confirmed. Keyed by lower-cased address.
+      // The reference is kept only for controlled cleanup; it is never served.
+      pendingReleaseByAddress = /* @__PURE__ */ new Map();
+      // Addresses whose pending release was confirmed late (after the caller gave
+      // up waiting) and still need a replacement client on the next recycle.
+      releaseConfirmedNeedsCreate = /* @__PURE__ */ new Set();
+      // Lower-cased addresses owned by a create. The slot is held from before the
+      // SDK factory runs until the new client is registered in `clients` (or the
+      // create failed), so no flow can observe "no lock and no client".
+      clientCreateInFlight = /* @__PURE__ */ new Set();
+      // Clients whose close() was confirmed; a repeated release is a no-op.
+      releasedClients = /* @__PURE__ */ new WeakSet();
+      // One listener setup per client, shared by concurrent init/refresh callers.
+      listenTaskByClient = /* @__PURE__ */ new WeakMap();
+      inboundReplayGateOwners = /* @__PURE__ */ new WeakMap();
+      releaseWaitTimeoutMs = 3e4;
+      releaseWaitSetTimeout = (callback, delayMs) => setTimeout(callback, delayMs);
+      releaseWaitClearTimeout = (timer) => clearTimeout(timer);
       nextClientGeneration = 1;
       clientGenerationByClient = /* @__PURE__ */ new WeakMap();
       resolveStartupReplayCompletion;
@@ -59194,6 +59306,56 @@ var init_xmtp_sdk = __esm({
         return { ok: remaining.length === 0, failures: remaining };
       }
       async createClientForAgent(agentInfo, options = {}) {
+        const address = agentInfo.communicationAddress;
+        const addressKey = address.toLowerCase();
+        let blockedReason;
+        if (this.pendingReleaseByAddress.has(addressKey)) {
+          blockedReason = "release_pending";
+        } else if (this.clientCreateInFlight.has(addressKey)) {
+          blockedReason = "create_in_flight";
+        } else if (this.getClientByAddress(address)) {
+          blockedReason = "client_active";
+        }
+        if (blockedReason) {
+          throw new XmtpClientCreateBlockedError(
+            blockedReason,
+            address,
+            agentInfo.agentId
+          );
+        }
+        this.clientCreateInFlight.add(addressKey);
+        try {
+          const created = await this.createClientForAgentGuarded(agentInfo, options);
+          await this.registerCreatedClient(created, options.logPrefix ?? "[xmtp-sdk]");
+          return created;
+        } finally {
+          this.clientCreateInFlight.delete(addressKey);
+        }
+      }
+      // Ownership hand-off, still inside the create slot: the new client becomes
+      // visible in `clients` before the slot is released. Never overwrites an
+      // existing registration; a conflicting new object is released, not dropped.
+      async registerCreatedClient(created, phase) {
+        const { address, agent, agentInfo } = created;
+        const addressKey = address.toLowerCase();
+        const existing = this.getClientByAddress(address);
+        if (existing && existing !== agent || this.pendingReleaseByAddress.has(addressKey)) {
+          const reason = existing ? "client_active" : "release_pending";
+          logWithTimestamp(
+            `[xmtp-sdk] create registration conflict (${reason}): ${address} (agentId=${agentInfo.agentId}), releasing the new client`
+          );
+          await this.releaseClient(
+            address,
+            agent,
+            agentInfo.agentId,
+            `${phase}/register-conflict`
+          );
+          throw new XmtpClientCreateBlockedError(reason, address, agentInfo.agentId);
+        }
+        this.stoppedAddresses.delete(addressKey);
+        this.clients.set(address, agent);
+      }
+      async createClientForAgentGuarded(agentInfo, options = {}) {
         const address = agentInfo.communicationAddress;
         const phase = options.logPrefix ?? "[xmtp-sdk]";
         const cooldown = getXmtpCreationCooldown();
@@ -59222,7 +59384,7 @@ var init_xmtp_sdk = __esm({
         try {
           const signer = this.tools.createSigner(agentInfo);
           const dbPath = (inboxId2) => `${this.dataDir}/${inboxId2}-${this.env}.db3`;
-          const agent = await createAgentWithInstallationPrune(signer, {
+          const agent = await this.xmtpAgentFactory(signer, {
             dbPath,
             env: this.env
           }, {
@@ -59231,6 +59393,7 @@ var init_xmtp_sdk = __esm({
             logPrefix: options.logPrefix
           });
           cooldown.recordCreateSuccess(decision);
+          this.releaseConfirmedNeedsCreate.delete(address.toLowerCase());
           if (decision.mode === "probe") {
             logger.info(LogEvent.XMTP_RATE_LIMIT_RECOVERED, {
               onchainosAgentId: agentInfo.agentId,
@@ -59268,6 +59431,128 @@ var init_xmtp_sdk = __esm({
           throw err2;
         }
       }
+      logReleaseNotConfirmed(address, agentId, phase, reason, err2) {
+        logger.error(
+          LogEvent.XMTP_CLIENT_CLOSE_FAILED,
+          err2 instanceof Error ? err2 : new Error(`xmtp client close not confirmed (${reason})`),
+          { walletAddress: address, onchainosAgentId: agentId, phase, reason }
+        );
+      }
+      // Single release entry (recycle / refresh remove / failed replacement).
+      // Confirmation is ONLY a successful client.close(); a timeout, a missing
+      // close() or a close failure keeps the old reference in
+      // pendingReleaseByAddress and blocks new creates for that address.
+      async releaseClient(address, client, agentId, phase) {
+        const key = address.toLowerCase();
+        if (this.releasedClients.has(client)) {
+          this.unpublishClient(address, client, phase);
+          return true;
+        }
+        const existing = this.pendingReleaseByAddress.get(key);
+        if (existing?.inFlight) {
+          this.unpublishClient(address, client, phase);
+          return false;
+        }
+        const entry = existing ?? { client, agentId, phase };
+        entry.client = client;
+        entry.agentId = agentId;
+        entry.phase = phase;
+        this.pendingReleaseByAddress.set(key, entry);
+        this.unpublishClient(address, client, phase);
+        let timedOut = false;
+        const task = stopAndCloseXmtpClient(client, {
+          address,
+          agentId,
+          phase,
+          onCloseError: (err2) => this.logReleaseNotConfirmed(address, agentId, phase, "close_threw", err2)
+        }).then((result) => {
+          if (!result.stopped) {
+            logWithTimestamp(
+              `[xmtp-sdk] release: stop failed but close proceeded: ${address} (agentId=${agentId}) phase=${phase}`
+            );
+          }
+          entry.inFlight = void 0;
+          if (result.closed) {
+            this.releasedClients.add(client);
+          }
+          if (result.closed && this.pendingReleaseByAddress.get(key) === entry) {
+            this.pendingReleaseByAddress.delete(key);
+            if (timedOut) {
+              this.releaseConfirmedNeedsCreate.add(key);
+            }
+          }
+          return result;
+        });
+        entry.inFlight = task.then((result) => result.closed);
+        const timeoutHandle = {};
+        const timeoutPromise = new Promise((resolve14) => {
+          timeoutHandle.timer = this.releaseWaitSetTimeout(
+            () => resolve14(null),
+            this.releaseWaitTimeoutMs
+          );
+        });
+        const outcome = await Promise.race([task, timeoutPromise]);
+        if (timeoutHandle.timer !== void 0) {
+          this.releaseWaitClearTimeout(timeoutHandle.timer);
+        }
+        if (outcome === null) {
+          timedOut = true;
+          this.logReleaseNotConfirmed(address, agentId, phase, "close_timeout");
+          return false;
+        }
+        if (outcome.closed) {
+          if (this.pendingReleaseByAddress.get(key) === entry) {
+            this.pendingReleaseByAddress.delete(key);
+          }
+          return true;
+        }
+        if (!outcome.closeFailed) {
+          this.logReleaseNotConfirmed(address, agentId, phase, "close_unavailable");
+        }
+        return false;
+      }
+      // Stops serving `client` to new operations. Every removal is identity
+      // checked, so a late caller can never remove a newer instance (or its replay
+      // gate / recovery / retry state) registered for the same address.
+      unpublishClient(address, client, phase) {
+        const key = address.toLowerCase();
+        let removed = false;
+        for (const [registeredAddress, registered] of this.clients) {
+          if (registered === client && registeredAddress.toLowerCase() === key) {
+            this.clients.delete(registeredAddress);
+            removed = true;
+          }
+        }
+        const gate = this.inboundReplayGates.get(key);
+        if (gate) {
+          const owner = this.inboundReplayGateOwners.get(gate);
+          if (owner === client || owner === void 0 && removed) {
+            this.inboundReplayGates.delete(key);
+          }
+        }
+        this.cancelStreamRecoveryForAddress(address, client);
+        if (removed) {
+          this.replayScanFailuresByAddress.delete(key);
+          this.clearReplayScanRetry(
+            address,
+            phase.startsWith("recycle") ? "client_recycled" : "client_removed"
+          );
+        }
+        if (!this.getClientByAddress(address)) {
+          this.stoppedAddresses.add(key);
+        }
+      }
+      async settlePendingRelease(address) {
+        const entry = this.pendingReleaseByAddress.get(address.toLowerCase());
+        if (!entry) {
+          return true;
+        }
+        if (entry.inFlight) {
+          return false;
+        }
+        const retryPhase = entry.phase.endsWith("/retry") ? entry.phase : `${entry.phase}/retry`;
+        return this.releaseClient(address, entry.client, entry.agentId, retryPhase);
+      }
       async recordInstallationHealth(params) {
         const { address, agent, agentInfo, phase, attempt } = params;
         try {
@@ -59388,8 +59673,6 @@ var init_xmtp_sdk = __esm({
           const r = results[i];
           if (r.status === "fulfilled") {
             const { address, agent, agentInfo } = r.value;
-            this.stoppedAddresses.delete(address.toLowerCase());
-            this.clients.set(address, agent);
             logWithTimestamp(
               `[xmtp-sdk] identity initialized: ${address} (agentId=${agentInfo.agentId})`
             );
@@ -59415,6 +59698,10 @@ var init_xmtp_sdk = __esm({
               phase: "init",
               attempt: "1"
             });
+          } else if (r.reason instanceof XmtpClientCreateBlockedError) {
+            logWithTimestamp(
+              `[xmtp-sdk] identity init: create blocked (${r.reason.reason}): ${agents[i].communicationAddress} (agentId=${agents[i].agentId})`
+            );
           } else {
             failedAgents.push(agents[i]);
             if (r.reason instanceof XmtpCreationCooldownSkipError) {
@@ -59451,8 +59738,6 @@ var init_xmtp_sdk = __esm({
             const r = retryResults[i];
             if (r.status === "fulfilled") {
               const { address, agent, agentInfo } = r.value;
-              this.stoppedAddresses.delete(address.toLowerCase());
-              this.clients.set(address, agent);
               logWithTimestamp(
                 `[xmtp-sdk] retry succeeded: ${address} (agentId=${agentInfo.agentId})`
               );
@@ -59478,6 +59763,11 @@ var init_xmtp_sdk = __esm({
                 phase: "init",
                 attempt: "2"
               });
+            } else if (r.reason instanceof XmtpClientCreateBlockedError) {
+              const info = failedAgents[i];
+              logWithTimestamp(
+                `[xmtp-sdk] retry create blocked (${r.reason.reason}): ${info.communicationAddress} (agentId=${info.agentId})`
+              );
             } else if (r.reason instanceof XmtpCreationCooldownSkipError) {
               const info = failedAgents[i];
               logWithTimestamp(
@@ -59560,36 +59850,38 @@ var init_xmtp_sdk = __esm({
             throw err2;
           }
         }
+        for (const pendingKey of [...this.pendingReleaseByAddress.keys()]) {
+          const settled = await this.settlePendingRelease(pendingKey);
+          logWithTimestamp(
+            `[xmtp-sdk] refresh: pending release ${pendingKey} ${settled ? "confirmed" : "still pending"}`
+          );
+        }
         const oldAddresses = new Set(
-          this.allAgents.map((a) => a.communicationAddress)
+          this.allAgents.map((a) => a.communicationAddress.toLowerCase())
+        );
+        const newAddresses = new Set(
+          newAgents.map((a) => a.communicationAddress.toLowerCase())
         );
-        const newAddresses = new Set(newAgents.map((a) => a.communicationAddress));
         const added = newAgents.filter(
-          (a) => !oldAddresses.has(a.communicationAddress) || !this.clients.has(a.communicationAddress)
+          (a) => !oldAddresses.has(a.communicationAddress.toLowerCase()) || !this.getClientByAddress(a.communicationAddress)
         );
         const removed = this.allAgents.filter(
-          (a) => !newAddresses.has(a.communicationAddress)
+          (a) => !newAddresses.has(a.communicationAddress.toLowerCase())
         );
         this.allAgents = newAgents;
         for (const agentInfo of removed) {
           const address = agentInfo.communicationAddress;
-          const client = this.clients.get(address);
+          const client = this.getClientByAddress(address);
           if (client) {
             try {
-              this.cancelStreamRecoveryForAddress(address);
-              this.stoppedAddresses.add(address.toLowerCase());
-              await stopAndCloseXmtpClient(client, {
+              const released = await this.releaseClient(
                 address,
-                agentId: agentInfo.agentId,
-                phase: "refresh/remove",
-                onCloseError: (err2) => logger.error(
-                  LogEvent.XMTP_CLIENT_CLOSE_FAILED,
-                  err2 instanceof Error ? err2 : new Error(String(err2)),
-                  { walletAddress: address, onchainosAgentId: agentInfo.agentId, phase: "refresh/remove" }
-                )
-              });
+                client,
+                agentInfo.agentId,
+                "refresh/remove"
+              );
               logWithTimestamp(
-                `[xmtp-sdk] refresh: stopped client: ${address} (agentId=${agentInfo.agentId})`
+                `[xmtp-sdk] refresh: stopped client: ${address} (agentId=${agentInfo.agentId}) released=${released}`
               );
             } catch (err2) {
               logWithTimestamp(`[xmtp-sdk] refresh: failed to stop client: ${address}`, err2);
@@ -59599,10 +59891,6 @@ var init_xmtp_sdk = __esm({
                 phase: "stop-client"
               });
             }
-            this.clients.delete(address);
-            this.inboundReplayGates.delete(address.toLowerCase());
-            this.replayScanFailuresByAddress.delete(address.toLowerCase());
-            this.clearReplayScanRetry(address, "client_removed");
             logger.info(LogEvent.AGENT_CLIENT_REMOVED, {
               ...agentExtras({
                 walletAddress: address,
@@ -59644,8 +59932,6 @@ var init_xmtp_sdk = __esm({
             const r = addResults[i];
             if (r.status === "fulfilled") {
               const { address, agentInfo } = r.value;
-              this.stoppedAddresses.delete(address.toLowerCase());
-              this.clients.set(address, r.value.agent);
               logWithTimestamp(
                 `[xmtp-sdk] refresh: identity initialized: ${address} (agentId=${agentInfo.agentId})`
               );
@@ -59672,6 +59958,10 @@ var init_xmtp_sdk = __esm({
                 phase: "refresh",
                 attempt: "1"
               });
+            } else if (r.reason instanceof XmtpClientCreateBlockedError) {
+              logWithTimestamp(
+                `[xmtp-sdk] refresh: create blocked (${r.reason.reason}): ${added[i].communicationAddress} (agentId=${added[i].agentId})`
+              );
             } else {
               failedAgents.push(added[i]);
               if (r.reason instanceof XmtpCreationCooldownSkipError) {
@@ -59711,8 +60001,6 @@ var init_xmtp_sdk = __esm({
               const r = retryResults[i];
               if (r.status === "fulfilled") {
                 const { address, agentInfo } = r.value;
-                this.stoppedAddresses.delete(address.toLowerCase());
-                this.clients.set(address, r.value.agent);
                 logWithTimestamp(
                   `[xmtp-sdk] refresh: retry succeeded: ${address} (agentId=${agentInfo.agentId})`
                 );
@@ -59739,6 +60027,11 @@ var init_xmtp_sdk = __esm({
                   phase: "refresh",
                   attempt: "2"
                 });
+              } else if (r.reason instanceof XmtpClientCreateBlockedError) {
+                const info = failedAgents[i];
+                logWithTimestamp(
+                  `[xmtp-sdk] refresh: retry create blocked (${r.reason.reason}): ${info.communicationAddress} (agentId=${info.agentId})`
+                );
               } else if (r.reason instanceof XmtpCreationCooldownSkipError) {
                 const info = failedAgents[i];
                 logWithTimestamp(
@@ -59764,7 +60057,8 @@ var init_xmtp_sdk = __esm({
             }
           }
           await this.startListeningForAddresses(
-            added.map((a) => a.communicationAddress)
+            added.map((a) => a.communicationAddress),
+            "refresh/listen-failed"
           );
           for (const agentInfo of added) {
             const address = agentInfo.communicationAddress;
@@ -59829,30 +60123,42 @@ var init_xmtp_sdk = __esm({
         }
         for (const agentInfo of this.allAgents) {
           const address = agentInfo.communicationAddress;
-          const oldClient = this.clients.get(address);
-          if (!oldClient) {
+          const addressKey = address.toLowerCase();
+          const oldClient = this.getClientByAddress(address);
+          const hasPendingRelease = this.pendingReleaseByAddress.has(addressKey) || this.releaseConfirmedNeedsCreate.has(addressKey);
+          if (!oldClient && !hasPendingRelease) {
             continue;
           }
-          const addressKey = address.toLowerCase();
-          try {
-            this.cancelStreamRecoveryForAddress(address);
-            this.stoppedAddresses.add(addressKey);
-            await stopAndCloseXmtpClient(oldClient, {
-              address,
-              agentId: agentInfo.agentId,
-              phase: "recycle",
-              onCloseError: (err2) => logger.error(
-                LogEvent.XMTP_CLIENT_CLOSE_FAILED,
-                err2 instanceof Error ? err2 : new Error(String(err2)),
-                { walletAddress: address, onchainosAgentId: agentInfo.agentId, phase: "recycle" }
-              )
-            });
-            this.clients.delete(address);
-            this.inboundReplayGates.delete(addressKey);
-            this.replayScanFailuresByAddress.delete(addressKey);
-            this.clearReplayScanRetry(address, "client_recycled");
+          if (!oldClient) {
+            let settled = false;
+            try {
+              settled = await this.settlePendingRelease(address);
+            } catch (err2) {
+              logWithTimestamp(`[xmtp-sdk] recycle: pending release retry failed: ${address}`, err2);
+            }
+            if (!settled) {
+              failed++;
+              continue;
+            }
+          } else {
+            let released = false;
+            try {
+              released = await this.releaseClient(
+                address,
+                oldClient,
+                agentInfo.agentId,
+                "recycle"
+              );
+            } catch (err2) {
+              logWithTimestamp(`[xmtp-sdk] recycle: failed to stop client: ${address}`, err2);
+              logger.error(LogEvent.AGENT_REFRESH_FAILED, err2 instanceof Error ? err2 : new Error(String(err2)), {
+                walletAddress: address,
+                onchainosAgentId: agentInfo.agentId,
+                phase: "recycle/stop-client"
+              });
+            }
             logWithTimestamp(
-              `[xmtp-sdk] recycle: stopped client: ${address} (agentId=${agentInfo.agentId})`
+              `[xmtp-sdk] recycle: stopped client: ${address} (agentId=${agentInfo.agentId}) released=${released}`
             );
             logger.info(LogEvent.AGENT_CLIENT_REMOVED, {
               ...agentExtras({
@@ -59862,23 +60168,18 @@ var init_xmtp_sdk = __esm({
               }),
               phase: "recycle"
             });
-          } catch (err2) {
-            failed++;
-            this.stoppedAddresses.delete(addressKey);
-            logWithTimestamp(`[xmtp-sdk] recycle: failed to stop client: ${address}`, err2);
-            logger.error(LogEvent.AGENT_REFRESH_FAILED, err2 instanceof Error ? err2 : new Error(String(err2)), {
-              walletAddress: address,
-              onchainosAgentId: agentInfo.agentId,
-              phase: "recycle/stop-client"
-            });
-            continue;
+            if (!released) {
+              failed++;
+              continue;
+            }
           }
+          let newAgent;
+          let newAgentReleased = false;
           try {
             const { agent } = await this.createClientForAgent(agentInfo, {
               logPrefix: "[xmtp-sdk:recycle]"
             });
-            this.stoppedAddresses.delete(addressKey);
-            this.clients.set(address, agent);
+            newAgent = agent;
             logWithTimestamp(
               `[xmtp-sdk] recycle: identity initialized: ${address} (agentId=${agentInfo.agentId})`
             );
@@ -59902,7 +60203,13 @@ var init_xmtp_sdk = __esm({
               agentInfo,
               phase: "recycle"
             });
-            await this.startListeningForAddresses([address]);
+            const listen = (await this.startListeningForAddresses([address], "recycle/listen-failed")).get(address);
+            if (listen?.client !== agent || !isListenHealthy(listen.outcome)) {
+              newAgentReleased = listen?.client === agent && listen.outcome === "failed";
+              throw new Error(
+                `xmtp listener not started (${listen?.client === agent ? listen.outcome : "client_replaced"})`
+              );
+            }
             const replayGate = this.inboundReplayGates.get(addressKey);
             let replaySummary;
             try {
@@ -59921,8 +60228,21 @@ var init_xmtp_sdk = __esm({
             recycled++;
           } catch (err2) {
             failed++;
-            this.cancelStreamRecoveryForAddress(address);
-            this.clients.delete(address);
+            if (newAgent && !newAgentReleased) {
+              try {
+                await this.releaseClient(
+                  address,
+                  newAgent,
+                  agentInfo.agentId,
+                  "recycle/create-failed"
+                );
+              } catch (releaseErr) {
+                logWithTimestamp(
+                  `[xmtp-sdk] recycle: failed to release new client: ${address}`,
+                  releaseErr
+                );
+              }
+            }
             logWithTimestamp(`[xmtp-sdk] recycle: failed to recreate client: ${address}`, err2);
             logger.error(
               LogEvent.XMTP_CONNECTION_FAILED,
@@ -60326,7 +60646,7 @@ var init_xmtp_sdk = __esm({
         }
       }
       async startListening() {
-        await this.startListeningForAddresses([...this.clients.keys()]);
+        await this.startListeningForAddresses([...this.clients.keys()], "listen-failed");
       }
       async drainInboundReplayGate(address, expectedGate) {
         if (!expectedGate) {
@@ -60391,11 +60711,22 @@ var init_xmtp_sdk = __esm({
         );
         return gate;
       }
-      cancelStreamRecoveryForAddress(address) {
+      // With `client`, only that client's recovery is cancelled, so a late caller
+      // cannot cancel the recovery of a newer instance on the same address.
+      cancelStreamRecoveryForAddress(address, client) {
         const addressKey = address.toLowerCase();
-        const cleanup = this.streamRecoveryCleanupByAddress.get(addressKey);
+        const entry = this.streamRecoveryCleanupByAddress.get(addressKey);
+        if (!entry || client && entry.client !== client) {
+          return;
+        }
         this.streamRecoveryCleanupByAddress.delete(addressKey);
-        cleanup?.();
+        entry.cleanup();
+      }
+      // True while `client` is the registered client of `address` (case-insensitive)
+      // and the address is neither stopped nor being released.
+      isCurrentListenOwner(address, client) {
+        const key = address.toLowerCase();
+        return this.getClientByAddress(address) === client && !this.stoppedAddresses.has(key) && !this.pendingReleaseByAddress.has(key);
       }
       getClientGeneration(client) {
         const existing = this.clientGenerationByClient.get(client);
@@ -60547,10 +60878,17 @@ var init_xmtp_sdk = __esm({
         this.notifyAgentsWakeupAfterReplay();
         return summary;
       }
-      async startListeningForAddresses(addresses) {
+      // Starts (at most once per client) the listener of every registered address
+      // and reports each outcome. A "failed" client, i.e. one with neither a live
+      // listener nor an owned retry task, is released with `releasePhase` before
+      // this returns, so it is never served as a healthy instance.
+      async startListeningForAddresses(addresses, releasePhase = "listen-failed") {
         const valid = addresses.filter((addr) => this.clients.has(addr));
-        await parallelMap(valid, async (address) => {
-          const agent = this.clients.get(address);
+        const targets = valid.map((address) => ({
+          address,
+          client: this.clients.get(address)
+        }));
+        const listenForClient = async (address, agent) => {
           const clientGeneration = this.getClientGeneration(agent);
           const addressKey = address.toLowerCase();
           const tag = `[xmtp-sdk:${address}]`;
@@ -60561,6 +60899,11 @@ var init_xmtp_sdk = __esm({
             onchainosAgentId: onchainosAgent?.agentId,
             role: onchainosAgent?.role
           };
+          const ownsAddress = () => this.isCurrentListenOwner(address, agent);
+          if (!ownsAddress()) {
+            logWithTimestamp(`${tag} listener setup skipped: client no longer current`);
+            return "skipped";
+          }
           try {
             await agent.client.conversations.syncAll([
               import_node_bindings2.ConsentState.Allowed,
@@ -60568,13 +60911,21 @@ var init_xmtp_sdk = __esm({
             ]);
             logWithTimestamp(`${tag} conversations synced (non-Denied)`);
           } catch (err2) {
-            logWithTimestamp(`${tag} conversation sync failed, skipping this client:`, err2);
+            if (!ownsAddress()) {
+              logWithTimestamp(`${tag} stale conversation sync failed after replacement, ignored:`, err2);
+              return "skipped";
+            }
+            logWithTimestamp(`${tag} conversation sync failed, listener not started:`, err2);
             logger.error(
               LogEvent.CONVERSATIONS_STREAM_FAILED,
               err2 instanceof Error ? err2 : void 0,
               agentExtras(identity)
             );
-            return;
+            return "failed";
+          }
+          if (!ownsAddress()) {
+            logWithTimestamp(`${tag} listener setup skipped after sync: client no longer current`);
+            return "skipped";
           }
           agent.use(loggingMiddleware(identity));
           agent.use(selfFilterMiddleware());
@@ -60603,6 +60954,7 @@ var init_xmtp_sdk = __esm({
             });
             const gate = new InboundReplayGate(inbound);
             this.inboundReplayGates.set(address.toLowerCase(), gate);
+            this.inboundReplayGateOwners.set(gate, agent);
             agent.use(gate.middleware);
           } else {
             logWithTimestamp(
@@ -60620,16 +60972,25 @@ var init_xmtp_sdk = __esm({
           const MAX_RETRIES = 5;
           const BASE_DELAY_MS = 1e3;
           const startWithRetry = async (attempt = 0) => {
-            if (this.stoppedAddresses.has(address.toLowerCase()) || !this.clients.has(address)) {
+            if (!ownsAddress()) {
               logWithTimestamp(`${tag} start skipped: client stopped or removed`);
-              return;
+              return "skipped";
             }
             try {
               const liveStreamOptions = {
                 consentStates: [import_node_bindings2.ConsentState.Allowed, import_node_bindings2.ConsentState.Unknown]
               };
               await agent.start(liveStreamOptions);
+              if (!ownsAddress()) {
+                logWithTimestamp(`${tag} stale agent.start resolved after replacement, ignored`);
+                return "skipped";
+              }
+              return "started";
             } catch (err2) {
+              if (!ownsAddress()) {
+                logWithTimestamp(`${tag} stale agent.start failed after replacement, ignored:`, err2);
+                return "skipped";
+              }
               logWithTimestamp(`${tag} agent.start error (attempt=${attempt}):`, err2);
               logger.error(
                 LogEvent.AGENT_START_FAILED,
@@ -60639,17 +61000,27 @@ var init_xmtp_sdk = __esm({
                   attempt: String(attempt)
                 }
               );
-              scheduleRetry(attempt);
+              return scheduleRetry(attempt);
             }
           };
           const scheduleRetry = (attempt) => {
-            if (this.stoppedAddresses.has(address.toLowerCase()) || !this.clients.has(address)) {
+            if (!ownsAddress()) {
               logWithTimestamp(`${tag} reconnect skipped: client stopped or removed`);
-              return;
+              return "skipped";
             }
             if (attempt >= MAX_RETRIES) {
-              logWithTimestamp(`${tag} reached max retries (${MAX_RETRIES}), giving up reconnect`);
-              return;
+              logWithTimestamp(
+                `${tag} reached max retries (${MAX_RETRIES}), giving up reconnect; releasing client`
+              );
+              void this.releaseClient(
+                address,
+                agent,
+                identity.onchainosAgentId ?? "",
+                "listen/retry-exhausted"
+              ).catch((err2) => {
+                logWithTimestamp(`${tag} release after retry exhaustion failed:`, err2);
+              });
+              return "failed";
             }
             const delay = BASE_DELAY_MS * 2 ** attempt;
             logWithTimestamp(`${tag} reconnecting in ${delay}ms (attempt=${attempt + 1})`);
@@ -60657,6 +61028,7 @@ var init_xmtp_sdk = __esm({
               () => void startWithRetry(attempt + 1),
               delay
             );
+            return "retrying";
           };
           const streamRecovery = new StreamRecoveryTelemetry();
           let recoveryTimeout;
@@ -60676,10 +61048,10 @@ var init_xmtp_sdk = __esm({
               recoveryStabilityTimeout = void 0;
             }
           };
-          this.streamRecoveryCleanupByAddress.set(
-            addressKey,
-            cleanupStreamRecovery
-          );
+          this.streamRecoveryCleanupByAddress.set(addressKey, {
+            client: agent,
+            cleanup: cleanupStreamRecovery
+          });
           agent.on("unhandledError", (err2) => {
             if (recoveryDisposed || this.clients.get(address) !== agent || this.stoppedAddresses.has(addressKey)) {
               return;
@@ -60841,9 +61213,54 @@ var init_xmtp_sdk = __esm({
               `${tag} agent message event msg=${msg?.id ?? "(unknown)"} kind=${msg?.kind ?? "(unknown)"} conv=${conversation?.id ?? msg?.conversationId ?? "(unknown)"} sender=${msg?.senderInboxId ?? "(unknown)"} isText=${typeof ctx.isText === "function" ? String(ctx.isText()) : "unknown"} preview="${previewDebugContent(msg?.content)}"`
             );
           });
-          await startWithRetry();
-          logWithTimestamp(`${tag} message listener started`);
+          const outcome = await startWithRetry();
+          logWithTimestamp(`${tag} message listener ${outcome}`);
+          return outcome;
+        };
+        const settled = await parallelMap(targets, async ({ address, client }) => {
+          let task = this.listenTaskByClient.get(client);
+          if (!task) {
+            task = listenForClient(address, client);
+            this.listenTaskByClient.set(client, task);
+          }
+          let outcome;
+          try {
+            outcome = await task;
+          } catch (err2) {
+            logWithTimestamp(`[xmtp-sdk:${address}] listener setup failed:`, err2);
+            logger.error(
+              LogEvent.AGENT_START_FAILED,
+              err2 instanceof Error ? err2 : new Error(String(err2)),
+              {
+                ...agentExtras({
+                  walletAddress: address,
+                  inboxId: client.client?.inboxId,
+                  onchainosAgentId: this.getAgentByAddress(address)?.agentId
+                }),
+                phase: "listener-setup"
+              }
+            );
+            outcome = "failed";
+          }
+          if (outcome === "failed") {
+            await this.releaseClient(
+              address,
+              client,
+              this.getAgentByAddress(address)?.agentId ?? "",
+              releasePhase
+            );
+          }
+          return outcome;
+        });
+        const results = /* @__PURE__ */ new Map();
+        targets.forEach(({ address, client }, i) => {
+          const r = settled[i];
+          results.set(address, {
+            client,
+            outcome: r.status === "fulfilled" ? r.value : "failed"
+          });
         });
+        return results;
       }
       async replayOfflineMessagesForAddress(address, expectedClient, trigger = "periodic_repair", recoveryIdentity) {
         const addressReplayStartedAt = Date.now();
@@ -70071,12 +70488,12 @@ async function runListenerWithLock(options, paths) {
       });
     }
   });
-  service.setPluginVersion("0.2.17");
+  service.setPluginVersion("0.2.18");
   await service.init();
   const pluginVersionStatus = service.pluginVersionStatus;
   if (pluginVersionStatus.unavailable) {
     throw new Error(
-      `@okxweb3/a2a-node v${"0.2.17"} is below the required minimum v${pluginVersionStatus.minVersion}`
+      `@okxweb3/a2a-node v${"0.2.18"} is below the required minimum v${pluginVersionStatus.minVersion}`
     );
   }
   const systemConfig = service.getSystemConfig();
@@ -70104,7 +70521,7 @@ async function runListenerWithLock(options, paths) {
       onchainosAgentId: "*",
       reason: "system-config missing sentryDsn",
       pluginId: "@okxweb3/a2a-node",
-      pluginVersion: "0.2.17"
+      pluginVersion: "0.2.18"
     });
   }
   logWithTimestamp(
@@ -118447,7 +118864,7 @@ async function getCurrentNodeCliVersion() {
   return await getGlobalNpmPackageVersion(UPDATE_PACKAGES.node) ?? getBundledNodeCliVersion();
 }
 function getBundledNodeCliVersion() {
-  return true ? "0.2.17" : null;
+  return true ? "0.2.18" : null;
 }
 function readConfiguredAiProvider() {
   const explicit = process.env.OKX_A2A_AI_PROVIDER || process.env.OKX_AGENT_TASK_AI_CLI;
@@ -118657,7 +119074,7 @@ async function updateHermes(release, options) {
   }
 }
 async function installGatewayPluginForDoctor(target) {
-  const release = isPrereleaseVersion("0.2.17") ? "beta" : "latest";
+  const release = isPrereleaseVersion("0.2.18") ? "beta" : "latest";
   const insideTargetGateway = detectGatewayInvocation() === target;
   const options = {
     restart: !insideTargetGateway,
@@ -119710,7 +120127,7 @@ async function runDoctor(options = {}) {
     platform: options.platform ?? process.platform,
     env: options.env ?? process.env,
     target: options.target ?? resolveDoctorTarget(options.env ?? process.env),
-    cliVersion: options.cliVersion ?? (true ? "0.2.17" : "0.0.0"),
+    cliVersion: options.cliVersion ?? (true ? "0.2.18" : "0.0.0"),
     fixMode: options.fix === true,
     nonInteractive: options.nonInteractive === true,
     packageChanged: false,
@@ -120817,7 +121234,7 @@ init_sentry_config();
 init_runtime_metadata();
 var CURRENT_GATEWAY_SESSION_KEYS_ENV4 = "OKX_A2A_CURRENT_GATEWAY_SESSION_KEYS";
 function printUsage3() {
-  console.log(`okx-a2a ${"0.2.17"}
+  console.log(`okx-a2a ${"0.2.18"}
 
 Usage:
   okx-a2a <command> [options]
@@ -120859,7 +121276,7 @@ Run \`okx-a2a <command> -h\` for command-specific help.
 `);
 }
 function printVersion() {
-  console.log("0.2.17");
+  console.log("0.2.18");
 }
 function printDaemonUsage() {
   console.log(`Usage: okx-a2a daemon <start|restart|stop|status|autostart> [options]
@@ -121485,12 +121902,12 @@ function assertOnlyKnownOptions(args, input) {
 async function queueXmtpDaemonCommand(args, type) {
   const json = hasFlag2(args, "--json");
   const timeoutMsRaw = readOption5(args, "--timeout-ms");
-  const wait3 = type === "xmtp-get-pending-list" || type === "xmtp-deny-pending-conversation" || type === "xmtp-refresh-agents";
+  const wait2 = type === "xmtp-get-pending-list" || type === "xmtp-deny-pending-conversation" || type === "xmtp-refresh-agents";
   await assertDaemonRunningForQueuedCommand2(type);
   const commands = new CommandStore();
   const command = type === "xmtp-get-pending-list" ? commands.createXmtpGetPendingListCommand() : type === "xmtp-deny-pending-conversation" ? commands.createXmtpDenyPendingConversationCommand(readDenyPendingConversationOptions(args)) : commands.createXmtpRefreshAgentsCommand();
   await commands.submit(command);
-  if (!wait3) {
+  if (!wait2) {
     outputCommandResult(json, { id: command.id, ok: true, completedAt: Date.now(), payload: { queued: true } }, `${type} queued command=${command.id}`);
     return;
   }
@@ -122354,10 +122771,10 @@ async function main() {
   if (command === "xmtp-test") {
     const { handleXmtpTestCommand: handleXmtpTestCommand2 } = await Promise.resolve().then(() => (init_xmtp_test_cli(), xmtp_test_cli_exports));
     await handleXmtpTestCommand2(process.argv.slice(3), {
-      packageVersion: "0.2.17",
-      agentSdkVersion: "2.3.0",
-      nodeSdkVersion: "6.1.0",
-      nodeBindingsVersion: "1.11.0"
+      packageVersion: "0.2.18",
+      agentSdkVersion: "2.3.1",
+      nodeSdkVersion: "6.1.1",
+      nodeBindingsVersion: "1.11.1"
     });
     return;
   }