@okxweb3/a2a-node 0.2.4-beta-e7a52faf6f-260812154627 → 0.2.4

package/dist/index.js

@@ -32104,7 +32104,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.4-beta-e7a52faf6f-260812154627",
+      release: "0.2.4",
       environment,
       runtimeContainer: normalizeRuntimeContainer(process.env.OKX_A2A_RUNTIME_CONTAINER)
     };
@@ -33045,7 +33045,7 @@ async function getCurrentNodeCliVersion() {
   return await getGlobalNpmPackageVersion(UPDATE_PACKAGES.node) ?? getBundledNodeCliVersion();
 }
 function getBundledNodeCliVersion() {
-  return true ? "0.2.4-beta-e7a52faf6f-260812154627" : null;
+  return true ? "0.2.4" : null;
 }
 function readConfiguredAiProvider() {
   const explicit = process.env.OKX_A2A_AI_PROVIDER || process.env.OKX_AGENT_TASK_AI_CLI;
@@ -33255,7 +33255,7 @@ async function updateHermes(release, options) {
   }
 }
 async function installGatewayPluginForDoctor(target) {
-  const release = isPrereleaseVersion("0.2.4-beta-e7a52faf6f-260812154627") ? "beta" : "latest";
+  const release = isPrereleaseVersion("0.2.4") ? "beta" : "latest";
   const insideTargetGateway = detectGatewayInvocation() === target;
   const options = {
     restart: !insideTargetGateway,
@@ -44020,7 +44020,6 @@ __export(index_exports, {
   buildLaunchdPlist: () => buildLaunchdPlist,
   buildLauncherEntryJs: () => buildLauncherEntryJs,
   buildMessageEligibleArgs: () => buildMessageEligibleArgs,
-  buildPendingConversationBackupDispatch: () => buildPendingConversationBackupDispatch,
   buildSchtasksCreateArgs: () => buildSchtasksCreateArgs,
   buildSchtasksDeleteArgs: () => buildSchtasksDeleteArgs,
   buildSchtasksEndArgs: () => buildSchtasksEndArgs,
@@ -44176,7 +44175,6 @@ __export(index_exports, {
   scanUserAttentionWatchers: () => scanUserAttentionWatchers,
   setOpenClawWebSocketFactoryForTests: () => setOpenClawWebSocketFactoryForTests,
   shouldDelegateToSupervisor: () => shouldDelegateToSupervisor,
-  shouldKeepInboundGroupPendingForBuyer: () => shouldKeepInboundGroupPendingForBuyer,
   shouldRouteThroughWindowsShell: () => shouldRouteThroughWindowsShell,
   spawnCompat: () => spawnCompat,
   spawnSyncCompat: () => spawnSyncCompat,
@@ -55414,6 +55412,7 @@ var StreamRecoveryTelemetry = class {
   }
   markError(nowMs = Date.now()) {
     if (this.activeRecovery) {
+      this.activeRecovery.candidateStartedAtMs = void 0;
       return {
         recoverySequence: this.activeRecovery.sequence,
         alreadyRecovering: true
@@ -55427,9 +55426,26 @@ var StreamRecoveryTelemetry = class {
     if (!this.activeRecovery) {
       return void 0;
     }
+    this.activeRecovery.candidateStartedAtMs = nowMs;
+    return {
+      recoverySequence: this.activeRecovery.sequence,
+      candidateStartedAtMs: nowMs
+    };
+  }
+  markStable(nowMs = Date.now()) {
+    if (this.activeRecovery?.candidateStartedAtMs === void 0) {
+      return void 0;
+    }
     const completed = {
       recoverySequence: this.activeRecovery.sequence,
-      recoveryDurationMs: Math.max(0, nowMs - this.activeRecovery.startedAtMs)
+      recoveryDurationMs: Math.max(
+        0,
+        this.activeRecovery.candidateStartedAtMs - this.activeRecovery.startedAtMs
+      ),
+      recoveryConfirmationDurationMs: Math.max(
+        0,
+        nowMs - this.activeRecovery.startedAtMs
+      )
     };
     this.activeRecovery = void 0;
     return completed;
@@ -55438,9 +55454,12 @@ var StreamRecoveryTelemetry = class {
     this.activeRecovery = void 0;
   }
 };
+function replayFlightDiscriminator(clientGeneration, isOfflineReplay) {
+  return isOfflineReplay ? `startup_offline:${clientGeneration}` : `online_repair:${clientGeneration}`;
+}
 var KeyedSingleFlight = class {
   inFlight = /* @__PURE__ */ new Map();
-  run(key, discriminator, operation) {
+  run(key, discriminator, operation, options = {}) {
     const normalizedKey = key.toLowerCase();
     const state = this.inFlight.get(normalizedKey);
     if (!state) {
@@ -55450,7 +55469,22 @@ var KeyedSingleFlight = class {
       return active.promise;
     }
     if (state.active.discriminator === discriminator) {
-      return state.active.promise;
+      if (!options.queueBehindActive) {
+        return state.active.promise;
+      }
+      const queued2 = state.queued.find(
+        (flight3) => flight3.discriminator === discriminator
+      );
+      if (queued2) {
+        return queued2.promise;
+      }
+      const flight2 = createKeyedFlight(
+        discriminator,
+        operation,
+        options.shouldRunAfterActive
+      );
+      state.queued.push(flight2);
+      return flight2.promise;
     }
     const queued = state.queued.find(
       (flight2) => flight2.discriminator === discriminator
@@ -55466,15 +55500,33 @@ var KeyedSingleFlight = class {
     void Promise.resolve().then(flight.operation).then(
       (value) => {
         flight.resolve(value);
-        this.advance(key, flight);
+        this.advanceAfterSuccess(key, flight, value);
       },
       (error) => {
         flight.reject(error);
-        this.advance(key, flight);
+        this.advanceAfterFailure(key, flight, error);
       }
     );
   }
-  advance(key, completed) {
+  advanceAfterSuccess(key, completed, value) {
+    const state = this.inFlight.get(key);
+    if (state?.active !== completed) {
+      return;
+    }
+    const next = state.queued.shift();
+    if (!next) {
+      this.inFlight.delete(key);
+      return;
+    }
+    if (next.shouldRunAfterActive && !next.shouldRunAfterActive(value)) {
+      next.resolve(value);
+      this.advanceAfterSuccess(key, completed, value);
+      return;
+    }
+    state.active = next;
+    this.execute(key, next);
+  }
+  advanceAfterFailure(key, completed, error) {
     const state = this.inFlight.get(key);
     if (state?.active !== completed) {
       return;
@@ -55484,18 +55536,30 @@ var KeyedSingleFlight = class {
       this.inFlight.delete(key);
       return;
     }
+    if (next.shouldRunAfterActive) {
+      next.reject(error);
+      this.advanceAfterFailure(key, completed, error);
+      return;
+    }
     state.active = next;
     this.execute(key, next);
   }
 };
-function createKeyedFlight(discriminator, operation) {
+function createKeyedFlight(discriminator, operation, shouldRunAfterActive) {
   let resolve11;
   let reject;
   const promise = new Promise((resolvePromise, rejectPromise) => {
     resolve11 = resolvePromise;
     reject = rejectPromise;
   });
-  return { discriminator, operation, promise, resolve: resolve11, reject };
+  return {
+    discriminator,
+    operation,
+    promise,
+    resolve: resolve11,
+    reject,
+    shouldRunAfterActive
+  };
 }
 
 // ../core/src/xmtp-sdk/extract-job-id.ts
@@ -56225,6 +56289,7 @@ var SYSTEM_CONFIG_DEFAULTS = {
   }
 };
 var STREAM_RECOVERY_ALERT_THRESHOLD_MS = 3e4;
+var STREAM_RECOVERY_STABILITY_WINDOW_MS = 1e4;
 var REPLAY_GATE_DRAIN_MAX_ATTEMPTS = 3;
 var REPLAY_GATE_DRAIN_RETRY_DELAY_MS = 100;
 var SEMVER_RE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*)?$/;
@@ -56417,11 +56482,11 @@ function replayScanBackoffMs(consecutiveFailures) {
 function isOfflineReplayForTrigger(trigger) {
   return trigger === "startup";
 }
-function replaySingleFlightDiscriminator(trigger, clientGeneration, recoveryIdentity) {
-  if (trigger === "stream_recovery") {
-    return `stream_recovery:${clientGeneration}:${recoveryIdentity ?? "unknown"}`;
-  }
-  return isOfflineReplayForTrigger(trigger) ? `startup_offline:${clientGeneration}` : `online_repair:${clientGeneration}`;
+function replaySingleFlightDiscriminator(trigger, clientGeneration) {
+  return replayFlightDiscriminator(
+    clientGeneration,
+    isOfflineReplayForTrigger(trigger)
+  );
 }
 var XmtpService = class _XmtpService {
   static instance = null;
@@ -56456,6 +56521,9 @@ var XmtpService = class _XmtpService {
   replayScanClearTimeout = (timer) => clearTimeout(timer);
   inboundReplayGates = /* @__PURE__ */ new Map();
   streamRecoveryCleanupByAddress = /* @__PURE__ */ new Map();
+  streamRecoverySetTimeout = (callback, delayMs) => setTimeout(callback, delayMs);
+  streamRecoveryClearTimeout = (timer) => clearTimeout(timer);
+  streamStartSetTimeout = (callback, delayMs) => setTimeout(callback, delayMs);
   nextClientGeneration = 1;
   clientGenerationByClient = /* @__PURE__ */ new WeakMap();
   resolveStartupReplayCompletion;
@@ -57908,10 +57976,14 @@ var XmtpService = class _XmtpService {
         }
         const delay = BASE_DELAY_MS * 2 ** attempt;
         logWithTimestamp(`${tag} reconnecting in ${delay}ms (attempt=${attempt + 1})`);
-        setTimeout(() => void startWithRetry(attempt + 1), delay);
+        this.streamStartSetTimeout(
+          () => void startWithRetry(attempt + 1),
+          delay
+        );
       };
       const streamRecovery = new StreamRecoveryTelemetry();
       let recoveryTimeout;
+      let recoveryStabilityTimeout;
       let pendingRecoveryGate;
       let recoveryDisposed = false;
       this.cancelStreamRecoveryForAddress(address);
@@ -57919,9 +57991,13 @@ var XmtpService = class _XmtpService {
         recoveryDisposed = true;
         streamRecovery.cancel();
         if (recoveryTimeout) {
-          clearTimeout(recoveryTimeout);
+          this.streamRecoveryClearTimeout(recoveryTimeout);
           recoveryTimeout = void 0;
         }
+        if (recoveryStabilityTimeout) {
+          this.streamRecoveryClearTimeout(recoveryStabilityTimeout);
+          recoveryStabilityTimeout = void 0;
+        }
       };
       this.streamRecoveryCleanupByAddress.set(
         addressKey,
@@ -57936,6 +58012,10 @@ var XmtpService = class _XmtpService {
           logger.error(LogEvent.AGENT_UNHANDLED_ERROR, err, agentExtras(identity));
           return;
         }
+        if (recoveryStabilityTimeout) {
+          this.streamRecoveryClearTimeout(recoveryStabilityTimeout);
+          recoveryStabilityTimeout = void 0;
+        }
         const recovery = streamRecovery.markError();
         const errorTelemetry = extractStreamErrorTelemetry(err);
         if (!recovery.alreadyRecovering) {
@@ -57950,10 +58030,11 @@ var XmtpService = class _XmtpService {
           recoveryAlreadyActive: String(recovery.alreadyRecovering)
         });
         if (!recovery.alreadyRecovering) {
-          recoveryTimeout = setTimeout(() => {
+          recoveryTimeout = this.streamRecoverySetTimeout(() => {
             if (recoveryDisposed || this.clients.get(address) !== agent || this.stoppedAddresses.has(addressKey) || streamRecovery.activeSequence !== recovery.recoverySequence) {
               return;
             }
+            recoveryTimeout = void 0;
             logger.error(LogEvent.AGENT_STREAM_RECOVERY_TIMEOUT, void 0, {
               ...agentExtras(identity),
               ...errorTelemetry,
@@ -57962,6 +58043,22 @@ var XmtpService = class _XmtpService {
               recoveryDurationMs: String(STREAM_RECOVERY_ALERT_THRESHOLD_MS),
               thresholdMs: String(STREAM_RECOVERY_ALERT_THRESHOLD_MS)
             });
+            const timedOutGate = pendingRecoveryGate;
+            pendingRecoveryGate = void 0;
+            void this.drainInboundReplayGate(address, timedOutGate).catch(
+              (drainError) => {
+                logger.error(
+                  LogEvent.OFFLINE_REPLAY_FAILED,
+                  drainError instanceof Error ? drainError : new Error(String(drainError)),
+                  {
+                    ...agentExtras(identity),
+                    clientGeneration: String(clientGeneration),
+                    recoverySequence: String(recovery.recoverySequence),
+                    stage: "streamRecovery/timeout-drain-gate"
+                  }
+                );
+              }
+            );
           }, STREAM_RECOVERY_ALERT_THRESHOLD_MS);
         }
       });
@@ -57969,60 +58066,61 @@ var XmtpService = class _XmtpService {
         if (recoveryDisposed || this.clients.get(address) !== agent || this.stoppedAddresses.has(addressKey)) {
           return;
         }
-        const recovery = streamRecovery.markStarted();
-        if (recoveryTimeout) {
-          clearTimeout(recoveryTimeout);
-          recoveryTimeout = void 0;
-        }
+        const candidate = streamRecovery.markStarted();
         logWithTimestamp(
           `${tag} agent stream started agentId=${identity.onchainosAgentId ?? "(unknown)"} inboxId=${identity.inboxId ?? "(unknown)"} role=${identity.role ?? "(unknown)"} consentStates=Allowed,Unknown lastSync=${formatLogTimestamp2(this.syncByAddress.get(address))}`
         );
-        if (recovery) {
-          const recoveryGate = pendingRecoveryGate;
-          pendingRecoveryGate = void 0;
-          logger.info(LogEvent.AGENT_STREAM_RECOVERED, {
-            ...agentExtras(identity),
-            clientGeneration: String(clientGeneration),
-            recoverySequence: String(recovery.recoverySequence),
-            recoveryDurationMs: String(recovery.recoveryDurationMs)
-          });
-          void (async () => {
-            try {
-              const summary = await this.replayOfflineMessagesForStreamRecovery(
-                address,
-                String(recovery.recoverySequence),
-                agent
-              );
-              if (summary.outcome === "completed" && !recoveryDisposed && this.clients.get(address) === agent) {
-                logger.info(LogEvent.AGENT_STREAM_RECOVERY_REPLAY_COMPLETED, {
-                  ...agentExtras(identity),
-                  clientGeneration: String(clientGeneration),
-                  recoverySequence: String(recovery.recoverySequence),
-                  replayed: String(summary.replayed),
-                  skipped: String(summary.skipped),
-                  conversationCount: String(summary.conversations),
-                  replayDurationMs: String(summary.durationMs),
-                  outcome: "success",
-                  replayOutcome: summary.outcome
-                });
-              }
-            } catch (err) {
-              logWithTimestamp(`${tag} recovery offline replay failed:`, err);
-              logger.error(
-                LogEvent.OFFLINE_REPLAY_FAILED,
-                err instanceof Error ? err : new Error(String(err)),
-                {
-                  ...agentExtras(identity),
-                  clientGeneration: String(clientGeneration),
-                  recoverySequence: String(recovery.recoverySequence),
-                  stage: "streamRecovery/replay"
-                }
-              );
-            } finally {
+        if (candidate) {
+          if (recoveryStabilityTimeout) {
+            this.streamRecoveryClearTimeout(recoveryStabilityTimeout);
+          }
+          recoveryStabilityTimeout = this.streamRecoverySetTimeout(() => {
+            recoveryStabilityTimeout = void 0;
+            if (recoveryDisposed || this.clients.get(address) !== agent || this.stoppedAddresses.has(addressKey) || streamRecovery.activeSequence !== candidate.recoverySequence) {
+              return;
+            }
+            const recovery = streamRecovery.markStable();
+            if (!recovery) {
+              return;
+            }
+            if (recoveryTimeout) {
+              this.streamRecoveryClearTimeout(recoveryTimeout);
+              recoveryTimeout = void 0;
+            }
+            const recoveryGate = pendingRecoveryGate;
+            pendingRecoveryGate = void 0;
+            logger.info(LogEvent.AGENT_STREAM_RECOVERED, {
+              ...agentExtras(identity),
+              clientGeneration: String(clientGeneration),
+              recoverySequence: String(recovery.recoverySequence),
+              recoveryDurationMs: String(recovery.recoveryDurationMs),
+              recoveryConfirmationDurationMs: String(
+                recovery.recoveryConfirmationDurationMs
+              ),
+              stabilityWindowMs: String(STREAM_RECOVERY_STABILITY_WINDOW_MS)
+            });
+            void (async () => {
               try {
-                await this.drainInboundReplayGate(address, recoveryGate);
+                const summary = await this.replayOfflineMessagesForStreamRecovery(
+                  address,
+                  String(recovery.recoverySequence),
+                  agent
+                );
+                if (summary.outcome === "completed" && !recoveryDisposed && this.clients.get(address) === agent) {
+                  logger.info(LogEvent.AGENT_STREAM_RECOVERY_REPLAY_COMPLETED, {
+                    ...agentExtras(identity),
+                    clientGeneration: String(clientGeneration),
+                    recoverySequence: String(recovery.recoverySequence),
+                    replayed: String(summary.replayed),
+                    skipped: String(summary.skipped),
+                    conversationCount: String(summary.conversations),
+                    replayDurationMs: String(summary.durationMs),
+                    outcome: "success",
+                    replayOutcome: summary.outcome
+                  });
+                }
               } catch (err) {
-                logWithTimestamp(`${tag} recovery replay gate drain failed:`, err);
+                logWithTimestamp(`${tag} recovery offline replay failed:`, err);
                 logger.error(
                   LogEvent.OFFLINE_REPLAY_FAILED,
                   err instanceof Error ? err : new Error(String(err)),
@@ -58030,12 +58128,28 @@ var XmtpService = class _XmtpService {
                     ...agentExtras(identity),
                     clientGeneration: String(clientGeneration),
                     recoverySequence: String(recovery.recoverySequence),
-                    stage: "streamRecovery/drain-gate"
+                    stage: "streamRecovery/replay"
                   }
                 );
+              } finally {
+                try {
+                  await this.drainInboundReplayGate(address, recoveryGate);
+                } catch (err) {
+                  logWithTimestamp(`${tag} recovery replay gate drain failed:`, err);
+                  logger.error(
+                    LogEvent.OFFLINE_REPLAY_FAILED,
+                    err instanceof Error ? err : new Error(String(err)),
+                    {
+                      ...agentExtras(identity),
+                      clientGeneration: String(clientGeneration),
+                      recoverySequence: String(recovery.recoverySequence),
+                      stage: "streamRecovery/drain-gate"
+                    }
+                  );
+                }
               }
-            }
-          })();
+            })();
+          }, STREAM_RECOVERY_STABILITY_WINDOW_MS);
         }
         if (process.env.XMTP_FORCE_DEBUG === "true") {
           void logDetails(agent).catch((err) => {
@@ -58054,7 +58168,7 @@ var XmtpService = class _XmtpService {
       logWithTimestamp(`${tag} message listener started`);
     });
   }
-  async replayOfflineMessagesForAddress(address, expectedClient, trigger = "periodic_repair") {
+  async replayOfflineMessagesForAddress(address, expectedClient, trigger = "periodic_repair", recoveryIdentity) {
     const addressReplayStartedAt = Date.now();
     const summary = createOfflineReplayAddressSummary(address);
     const isOfflineReplay = isOfflineReplayForTrigger(trigger);
@@ -58154,6 +58268,8 @@ var XmtpService = class _XmtpService {
           walletAddress: address,
           stage: `offlineReplay/${stage}`,
           trigger,
+          clientGeneration: String(clientGeneration),
+          ...recoveryIdentity ? { recoverySequence: recoveryIdentity } : {},
           outcome: "failed",
           replayOutcome: summary.outcome,
           consecutiveFailures: String(consecutiveFailures),
@@ -58348,8 +58464,7 @@ var XmtpService = class _XmtpService {
     const clientGeneration = expectedClient ? this.getClientGeneration(expectedClient) : "missing";
     const eligibilityClass = replaySingleFlightDiscriminator(
       trigger,
-      clientGeneration,
-      recoveryIdentity
+      clientGeneration
     );
     return this.offlineReplaySingleFlight.run(
       address,
@@ -58359,9 +58474,14 @@ var XmtpService = class _XmtpService {
         return this.replayOfflineMessagesForAddress(
           address,
           expectedClient,
-          trigger
+          trigger,
+          recoveryIdentity
         );
-      }
+      },
+      trigger === "stream_recovery" ? {
+        queueBehindActive: true,
+        shouldRunAfterActive: (summary) => summary.outcome === "completed"
+      } : void 0
     );
   }
   async replayOfflineMessagesForStreamRecovery(address, recoveryIdentity, expectedClient) {
@@ -58419,12 +58539,6 @@ function createOfflineReplayAddressSummary(address) {
   };
 }
 
-// ../core/src/a2a/pending-conversation.ts
-var PENDING_CONVERSATION_BACKUP_NOTICE_TEMPLATE = "[event:provider_conversation][jobId:${jobId}] There are new conversation requests pending.";
-function buildPendingConversationBackupNotice(jobId) {
-  return PENDING_CONVERSATION_BACKUP_NOTICE_TEMPLATE.replace("${jobId}", jobId);
-}
-
 // ../core/src/a2a/index.ts
 var A2A_MESSAGE_TYPE = "a2a-agent-chat";
 
@@ -60281,7 +60395,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     client: {
       id: "gateway-client",
       displayName: "okx-a2a-node",
-      version: "0.2.4-beta-e7a52faf6f-260812154627",
+      version: "0.2.4",
       platform: "node",
       mode: "backend",
       instanceId
@@ -60292,7 +60406,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     commands: [],
     permissions: {},
     locale: Intl.DateTimeFormat().resolvedOptions().locale || "en-US",
-    userAgent: `okx-a2a-node/${"0.2.4-beta-e7a52faf6f-260812154627"}`,
+    userAgent: `okx-a2a-node/${"0.2.4"}`,
     auth: {
       ...config.token ? { token: config.token } : {},
       ...config.password ? { password: config.password } : {}
@@ -64571,17 +64685,22 @@ async function maybeAllowProviderGroup(deps, chatType, conversationId) {
     );
   }
 }
-function shouldKeepInboundGroupPendingForBuyer(input) {
-  return input.consentState === import_node_bindings2.ConsentState.Unknown && !input.hasExistingSession && (input.localAgentRole === 1 /* CLIENT */ || input.localAgentRole == null);
-}
-function buildPendingConversationBackupDispatch(input) {
-  return {
-    sessionKey: buildBackupJobSessionKey(input.jobId),
-    content: buildPendingConversationBackupNotice(input.jobId),
-    messageId: `pending-conversation:${input.messageId}`,
+function ensureInboundGroupSession(deps, input) {
+  const sessionKey = buildSessionKey({
     jobId: input.jobId,
-    agentId: null
-  };
+    myAgentId: input.myAgentId,
+    toAgentId: input.toAgentId
+  });
+  deps.sessionStore?.upsertSession({
+    sessionKey,
+    jobId: input.jobId,
+    myAgentId: input.myAgentId,
+    toAgentId: input.toAgentId,
+    groupId: input.groupId,
+    myAgentXmtpAddress: deps.myXmtpAddress,
+    toAgentXmtpAddress: input.toAgentXmtpAddress
+  });
+  return sessionKey;
 }
 var INBOUND_TRANSPORT = "xmtp";
 var INBOUND_EVENT_FAMILY = "inbound";
@@ -64647,30 +64766,6 @@ function buildInboundTerminalExtras(input) {
     })
   };
 }
-function notifyPendingConversationToBackup(params) {
-  const event = buildPendingConversationBackupDispatch({
-    jobId: params.jobId,
-    messageId: params.messageId
-  });
-  void Promise.resolve(params.deps.onSessionMessage?.(event)).catch((err) => {
-    logWithTimestamp(`[okx-agent-task:${params.deps.myXmtpAddress}] pending conversation backup dispatch failed:`, err);
-    logger.error(LogEvent.INBOUND_DISPATCH_FAILED, toLoggableError(err), {
-      ...buildInboundTerminalExtras({
-        terminalState: "dispatch_failed",
-        myXmtpAddress: params.deps.myXmtpAddress,
-        messageId: event.messageId,
-        jobId: params.jobId,
-        sessionKey: event.sessionKey,
-        route: "backup",
-        reason: "pending_backup_dispatch_failed"
-      }),
-      // Each fire-and-forget dispatch overrides the generic checkpoint with the
-      // `_failed` twin of its own success checkpoint, so the four paths stay
-      // distinguishable in the funnel.
-      checkpoint: "inbound/pending_backup_dispatch_failed"
-    });
-  });
-}
 function maybeNotifyInboundAgentMessage(params) {
   if (params.chatType === "dm") {
     return;
@@ -65478,7 +65573,7 @@ async function processFileMessage(ctx, deps, options = {}) {
     }
     const sender = isPlainObject3(payloadObject?.sender) ? payloadObject.sender : null;
     const localAgent = service.getAgentByAddress(deps.myXmtpAddress);
-    const myAgentId = localAgent?.agentId ?? sessionAgentId ?? null;
+    const myAgentId = localAgent?.agentId ?? readString3(payloadObject?.receiverAgentId) ?? sessionAgentId ?? null;
     const toAgentId = readString3(sender?.agentId);
     const accepted = await verifyInboundA2AGroupMessage({
       payload: parsed.parsed ? parsed.payload : null,
@@ -65496,50 +65591,13 @@ async function processFileMessage(ctx, deps, options = {}) {
     if (!accepted) {
       return true;
     }
-    const sessionKey = buildSessionKey({
-      jobId: route.jobId,
-      myAgentId,
-      toAgentId
-    });
-    const existingSession = deps.sessionStore?.getSession(sessionKey) ?? null;
     const routedMessageId = messageId || `group-${(0, import_node_crypto12.randomUUID)()}`;
-    const consentState = ctx.conversation instanceof Group ? ctx.conversation.consentState() : void 0;
-    if (shouldKeepInboundGroupPendingForBuyer({
-      consentState,
-      localAgentRole: localAgent?.role ?? null,
-      hasExistingSession: !!existingSession
-    })) {
-      logWithTimestamp(
-        `[okx-agent-task:${deps.myXmtpAddress}] buyer inbound group kept pending: session=${sessionKey} job=${shortenLogValue(route.jobId)} group=${conversationId} consent=${String(consentState)} message=${shortenLogValue(routedMessageId)}`
-      );
-      logger.info(LogEvent.INBOUND_BUYER_PENDING, {
-        ...agentExtras({ walletAddress: deps.myXmtpAddress, onchainosAgentId: localAgent?.agentId }),
-        peerWalletAddress: senderAddress,
-        peerInboxId: ctx.message.senderInboxId ?? "",
-        peerAgentId: toAgentId ?? "",
-        taskId: route.jobId,
-        conversationId,
-        messageId: routedMessageId,
-        consentState: String(consentState),
-        ...inboundStageExtras("inbound/buyer_pending", "pending"),
-        reason: "unknown_group_without_session",
-        ...timing.extras()
-      });
-      notifyPendingConversationToBackup({
-        deps,
-        jobId: route.jobId,
-        messageId: routedMessageId
-      });
-      return true;
-    }
-    deps.sessionStore?.upsertSession({
-      sessionKey,
+    const sessionKey = ensureInboundGroupSession(deps, {
       jobId: route.jobId,
       myAgentId,
       toAgentId,
-      groupId: conversationId || null,
-      myAgentXmtpAddress: deps.myXmtpAddress,
-      toAgentXmtpAddress: senderAddress || null
+      groupId: conversationId,
+      toAgentXmtpAddress: senderAddress || readString3(payloadObject?.fromXmtpAddress)
     });
     const dispatchStartedAt = Date.now();
     void Promise.resolve(deps.onSessionMessage?.({
@@ -66507,12 +66565,12 @@ async function runListenerWithLock(options, paths) {
       });
     }
   });
-  service.setPluginVersion("0.2.4-beta-e7a52faf6f-260812154627");
+  service.setPluginVersion("0.2.4");
   await service.init();
   const pluginVersionStatus = service.pluginVersionStatus;
   if (pluginVersionStatus.unavailable) {
     throw new Error(
-      `@okxweb3/a2a-node v${"0.2.4-beta-e7a52faf6f-260812154627"} is below the required minimum v${pluginVersionStatus.minVersion}`
+      `@okxweb3/a2a-node v${"0.2.4"} is below the required minimum v${pluginVersionStatus.minVersion}`
     );
   }
   const systemConfig = service.getSystemConfig();
@@ -66530,7 +66588,7 @@ async function runListenerWithLock(options, paths) {
       onchainosAgentId: "*",
       reason: "system-config missing sentryDsn",
       pluginId: "@okxweb3/a2a-node",
-      pluginVersion: "0.2.4-beta-e7a52faf6f-260812154627"
+      pluginVersion: "0.2.4"
     });
   }
   logWithTimestamp(
@@ -69228,7 +69286,7 @@ async function exportDiagnosticLogs(options) {
     node: process.version,
     platform: process.platform,
     arch: process.arch,
-    packageVersion: true ? "0.2.4-beta-e7a52faf6f-260812154627" : "unknown",
+    packageVersion: true ? "0.2.4" : "unknown",
     sensitiveContentIncluded: options.includeSensitiveContent,
     listenerAndLlmContentIncluded: true,
     credentialsAlwaysRedacted: true,
@@ -71064,7 +71122,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.4-beta-e7a52faf6f-260812154627" : "0.0.0"),
+    cliVersion: options.cliVersion ?? (true ? "0.2.4" : "0.0.0"),
     fixMode: options.fix === true,
     nonInteractive: options.nonInteractive === true,
     packageChanged: false,
@@ -71361,7 +71419,6 @@ init_autostart_windows();
   buildLaunchdPlist,
   buildLauncherEntryJs,
   buildMessageEligibleArgs,
-  buildPendingConversationBackupDispatch,
   buildSchtasksCreateArgs,
   buildSchtasksDeleteArgs,
   buildSchtasksEndArgs,
@@ -71517,7 +71574,6 @@ init_autostart_windows();
   scanUserAttentionWatchers,
   setOpenClawWebSocketFactoryForTests,
   shouldDelegateToSupervisor,
-  shouldKeepInboundGroupPendingForBuyer,
   shouldRouteThroughWindowsShell,
   spawnCompat,
   spawnSyncCompat,