@okxweb3/a2a-node 0.2.1-beta-8ae7a0d300-260807161635 → 0.2.1

package/dist/cli.js

@@ -9433,7 +9433,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     client: {
       id: "gateway-client",
       displayName: "okx-a2a-node",
-      version: "0.2.1-beta-8ae7a0d300-260807161635",
+      version: "0.2.1",
       platform: "node",
       mode: "backend",
       instanceId
@@ -9444,7 +9444,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     commands: [],
     permissions: {},
     locale: Intl.DateTimeFormat().resolvedOptions().locale || "en-US",
-    userAgent: `okx-a2a-node/${"0.2.1-beta-8ae7a0d300-260807161635"}`,
+    userAgent: `okx-a2a-node/${"0.2.1"}`,
     auth: {
       ...config.token ? { token: config.token } : {},
       ...config.password ? { password: config.password } : {}
@@ -25478,6 +25478,8 @@ var init_events = __esm({
       XMTP_DEBUG_SYNC_REQUESTED: "XMTP debug sync requested",
       XMTP_DEBUG_SYNC_COMPLETED: "XMTP debug sync completed",
       AGENT_CLIENT_REMOVED: "Agent client removed",
+      AGENT_STREAM_RECOVERED: "Agent stream recovered",
+      AGENT_STREAM_RECOVERY_REPLAY_COMPLETED: "Agent stream recovery replay completed",
       ADDRESS_SYNC_COMPLETED: "Address sync completed",
       AGENT_REFRESH_SESSION_EXPIRED: "Agent refresh aborted: onchainos session expired, local clients taken offline",
       OFFLINE_REPLAY_MESSAGE_REPLAYED: "Offline replay message replayed",
@@ -25512,6 +25514,8 @@ var init_events = __esm({
       CONVERSATIONS_STREAM_FAILED: "conversations.stream failed",
       AGENT_START_FAILED: "agent.start failed",
       AGENT_STREAM_ERROR: "agent stream error",
+      AGENT_UNHANDLED_ERROR: "Agent unhandled error",
+      AGENT_STREAM_RECOVERY_TIMEOUT: "Agent stream recovery timeout",
       BOOTSTRAP_FAILED: "Bootstrap failed",
       ONCHAINOS_SESSION_EXPIRED: "Onchainos session expired",
       ONCHAINOS_CLI_ERROR: "Onchainos CLI error",
@@ -25521,6 +25525,7 @@ var init_events = __esm({
       MESSAGE_PARSE_FAILED: "Message parse failed",
       MESSAGE_HANDLER_ERROR: "Message handler error",
       INBOUND_DISPATCH_FAILED: "Inbound dispatch failed",
+      INBOUND_REPLAY_GATE_DRAIN_FAILED: "Inbound replay gate drain failed",
       // Default name stamped on events that reach Sentry without going through this
       // logger — uncaught exceptions and unhandled rejections. Without it those
       // events carry no eventName and cannot be classified.
@@ -25818,7 +25823,10 @@ var init_xmtp_test_metrics = __esm({
       "Address sync completed",
       "Agent client created",
       "Agent client removed",
-      "Agent stream error",
+      "agent stream error",
+      "Agent stream recovered",
+      "Agent stream recovery replay completed",
+      "Agent stream recovery timeout",
       "conversations.stream failed",
       "Inbound delivered to session",
       "Inbound dispatch failed",
@@ -25837,6 +25845,190 @@ var init_xmtp_test_metrics = __esm({
   }
 });
 
+// ../core/src/sentry-logger/error-diagnostics.ts
+function asErrorLike(value) {
+  return value instanceof Error ? value : void 0;
+}
+function diagnosticToken(value) {
+  if (typeof value !== "string" && typeof value !== "number") {
+    return void 0;
+  }
+  const token = String(value).trim();
+  if (!token || /^(?:null|undefined|unknown)$/i.test(token)) {
+    return void 0;
+  }
+  if (!/^[A-Za-z0-9_.:-]+$/.test(token)) {
+    return void 0;
+  }
+  return token.slice(0, MAX_DIAGNOSTIC_TOKEN_LENGTH);
+}
+function syscallToken(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const operation = diagnosticToken(value.trim().split(/\s+/, 1)[0])?.toLowerCase();
+  return operation && KNOWN_SYSCALLS.has(operation) ? operation : void 0;
+}
+function knownErrorCode(value) {
+  const code = diagnosticToken(value)?.toUpperCase();
+  return code && KNOWN_ERROR_CODES.has(code) ? code : void 0;
+}
+function readCode(error) {
+  return knownErrorCode(error?.code) ?? knownErrorCode(error?.errno);
+}
+function classifyError(error, code) {
+  const normalizedCode = code?.toUpperCase();
+  const name = error?.name.toLowerCase() ?? "";
+  const message = error?.message.toLowerCase() ?? "";
+  if (normalizedCode && RESOURCE_EXHAUSTED_CODES.has(normalizedCode)) {
+    return "resource_exhausted";
+  }
+  if (normalizedCode && CONNECTION_INTERRUPTED_CODES.has(normalizedCode)) {
+    return "connection_interrupted";
+  }
+  if (normalizedCode && NETWORK_UNAVAILABLE_CODES.has(normalizedCode)) {
+    return "network_unavailable";
+  }
+  if (normalizedCode && TIMEOUT_CODES.has(normalizedCode)) {
+    return "timeout";
+  }
+  if (normalizedCode && PERMISSION_CODES.has(normalizedCode)) {
+    return "permission_denied";
+  }
+  if (normalizedCode === "ENOENT") {
+    return "missing_dependency";
+  }
+  if (normalizedCode === "ABORT_ERR" || name === "aborterror") {
+    return "cancelled";
+  }
+  if (name === "syntaxerror" || /(?:json|response).*(?:parse|invalid)/.test(message)) {
+    return "invalid_response";
+  }
+  if (/session\s+(?:is\s+)?expired|login\s+expired/.test(message)) {
+    return "session_expired";
+  }
+  if (/timed?\s*out|timeout/.test(message)) {
+    return "timeout";
+  }
+  return "unknown";
+}
+function retryabilityFor(category) {
+  switch (category) {
+    case "connection_interrupted":
+    case "network_unavailable":
+    case "resource_exhausted":
+    case "timeout":
+      return "retryable";
+    case "invalid_response":
+    case "missing_dependency":
+    case "permission_denied":
+    case "session_expired":
+      return "non_retryable";
+    default:
+      return "unknown";
+  }
+}
+function causeChain(error) {
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current && chain.length < MAX_CAUSE_DEPTH && !seen.has(current)) {
+    chain.push(current);
+    seen.add(current);
+    current = asErrorLike(current.cause);
+  }
+  return chain;
+}
+function buildErrorDiagnostics(eventName, error, existingExtra) {
+  const errorLike = asErrorLike(error);
+  const legacy = {};
+  if (errorLike) {
+    legacy.errorName = errorLike.name;
+    legacy.errorMessageLength = String(errorLike.message.length);
+  }
+  if (!errorLike || eventName === LogEvent.AGENT_STREAM_ERROR) {
+    return legacy;
+  }
+  const chain = causeChain(errorLike);
+  const primary = chain[0];
+  const cause = chain.length > 1 ? chain[chain.length - 1] : void 0;
+  const fallbackExitCode = diagnosticToken(existingExtra.exitCode);
+  const primaryCode = readCode(primary);
+  const primaryCategory = classifyError(primary, primaryCode);
+  const primarySyscall = syscallToken(primary.syscall);
+  const causeCode = readCode(cause);
+  const causeCategory = cause ? classifyError(cause, causeCode) : void 0;
+  const causeSyscall = syscallToken(cause?.syscall);
+  const classifiedCategory = primaryCategory === "unknown" && causeCategory ? causeCategory : primaryCategory;
+  const effectiveCategory = classifiedCategory === "unknown" && fallbackExitCode && fallbackExitCode !== "0" ? "process_exit" : classifiedCategory;
+  const effectiveCode = primaryCode ?? causeCode;
+  const effectiveSyscall = primarySyscall ?? causeSyscall;
+  return {
+    ...legacy,
+    errorCategory: effectiveCategory,
+    errorRetryability: retryabilityFor(effectiveCategory),
+    errorCauseDepth: String(Math.max(0, chain.length - 1)),
+    ...effectiveCode ? { errorCode: effectiveCode } : {},
+    ...effectiveSyscall ? { errorSyscall: effectiveSyscall } : {},
+    ...cause ? {
+      causeErrorMessageLength: String(cause.message.length),
+      causeErrorCategory: causeCategory ?? "unknown",
+      ...causeCode ? { causeErrorCode: causeCode } : {},
+      ...causeSyscall ? { causeErrorSyscall: causeSyscall } : {}
+    } : {}
+  };
+}
+var MAX_DIAGNOSTIC_TOKEN_LENGTH, MAX_CAUSE_DEPTH, RESOURCE_EXHAUSTED_CODES, CONNECTION_INTERRUPTED_CODES, NETWORK_UNAVAILABLE_CODES, TIMEOUT_CODES, PERMISSION_CODES, KNOWN_ERROR_CODES, KNOWN_SYSCALLS;
+var init_error_diagnostics = __esm({
+  "../core/src/sentry-logger/error-diagnostics.ts"() {
+    "use strict";
+    init_events();
+    MAX_DIAGNOSTIC_TOKEN_LENGTH = 64;
+    MAX_CAUSE_DEPTH = 4;
+    RESOURCE_EXHAUSTED_CODES = /* @__PURE__ */ new Set(["EAGAIN", "EMFILE", "ENFILE", "ENOMEM"]);
+    CONNECTION_INTERRUPTED_CODES = /* @__PURE__ */ new Set(["ECONNRESET", "EPIPE"]);
+    NETWORK_UNAVAILABLE_CODES = /* @__PURE__ */ new Set([
+      "EAI_AGAIN",
+      "ECONNREFUSED",
+      "EHOSTUNREACH",
+      "ENETDOWN",
+      "ENETUNREACH",
+      "ENOTFOUND"
+    ]);
+    TIMEOUT_CODES = /* @__PURE__ */ new Set(["ETIMEDOUT", "ESOCKETTIMEDOUT"]);
+    PERMISSION_CODES = /* @__PURE__ */ new Set(["EACCES", "EPERM"]);
+    KNOWN_ERROR_CODES = /* @__PURE__ */ new Set([
+      ...RESOURCE_EXHAUSTED_CODES,
+      ...CONNECTION_INTERRUPTED_CODES,
+      ...NETWORK_UNAVAILABLE_CODES,
+      ...TIMEOUT_CODES,
+      ...PERMISSION_CODES,
+      "ABORT_ERR",
+      "ENOENT"
+    ]);
+    KNOWN_SYSCALLS = /* @__PURE__ */ new Set([
+      "access",
+      "bind",
+      "close",
+      "connect",
+      "getaddrinfo",
+      "kill",
+      "listen",
+      "mkdir",
+      "open",
+      "read",
+      "readdir",
+      "readlink",
+      "rename",
+      "rmdir",
+      "spawn",
+      "stat",
+      "unlink",
+      "write"
+    ]);
+  }
+});
+
 // ../core/src/sentry-logger/index.ts
 function applyFatalEventDefaults(event) {
   try {
@@ -25882,6 +26074,7 @@ var init_sentry_logger = __esm({
     init_events();
     init_log_fields();
     init_xmtp_test_metrics();
+    init_error_diagnostics();
     init_events();
     init_log_fields();
     FLOW_ID = (0, import_node_crypto5.randomUUID)();
@@ -25969,14 +26162,23 @@ var init_sentry_logger = __esm({
       "agentId",
       "agentPlatform",
       "cacheName",
+      "causeCode",
+      "causeType",
+      "causeVariant",
       "checkpoint",
       "code",
       "communicationClass",
       "component",
       "eventFamily",
       "eventName",
+      "endpoint",
+      "errorCategory",
+      "errorCode",
+      "errorRetryability",
+      "errorSyscall",
       "exitCode",
       "fromAgentId",
+      "grpcMethod",
       "jobId",
       "kind",
       "method",
@@ -26000,17 +26202,24 @@ var init_sentry_logger = __esm({
       "source",
       "stage",
       "status",
+      "streamErrorCode",
+      "streamType",
       "subcommand",
       "systemEvent",
       "taskId",
       "taskMode",
       "toAgentId",
       "transport",
+      "transportFailure",
+      "transportProtocol",
       "type",
       "workloadClass"
     ]);
     SENTRY_FINGERPRINT_KEYS = [
       "eventName",
+      "errorCategory",
+      "errorCode",
+      "errorSyscall",
       "cacheName",
       "component",
       "method",
@@ -26074,6 +26283,9 @@ var init_sentry_logger = __esm({
       LogEvent.MESSAGE_SENT,
       LogEvent.AGENT_CLIENT_CREATED,
       LogEvent.AGENT_CLIENT_REMOVED,
+      LogEvent.AGENT_STREAM_ERROR,
+      LogEvent.AGENT_STREAM_RECOVERED,
+      LogEvent.AGENT_STREAM_RECOVERY_REPLAY_COMPLETED,
       LogEvent.ADDRESS_SYNC_COMPLETED,
       LogEvent.AGENTS_REFRESHED,
       LogEvent.AGENTS_WAKEUP_NOTIFIED,
@@ -26205,19 +26417,24 @@ var init_sentry_logger = __esm({
       }
       captureError(message, error, extraWithFlow) {
         try {
+          const errorDiagnostics = buildErrorDiagnostics(
+            message,
+            error,
+            extraWithFlow
+          );
+          const diagnosticExtra = {
+            ...extraWithFlow,
+            ...errorDiagnostics
+          };
           Sentry.withScope((scope) => {
             scope.setLevel("error");
-            _SentryLogger.applyDiagnostics(scope, message, extraWithFlow);
+            _SentryLogger.applyDiagnostics(scope, message, diagnosticExtra);
             Sentry.captureException(_SentryLogger.createSentryEvent(message), {
               // eventName is unconditional: callers that pass no Error object are
               // still classified events, and without it they reach SLS anonymous.
               extra: {
-                ...extraWithFlow,
-                eventName: message,
-                ...error ? {
-                  errorName: error.name,
-                  errorMessageLength: String(error.message.length)
-                } : {}
+                ...diagnosticExtra,
+                eventName: message
               }
             });
           });
@@ -27416,7 +27633,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.1-beta-8ae7a0d300-260807161635",
+      release: "0.2.1",
       environment,
       runtimeContainer: normalizeRuntimeContainer(process.env.OKX_A2A_RUNTIME_CONTAINER)
     };
@@ -38586,7 +38803,7 @@ async function exportDiagnosticLogs(options) {
     node: process.version,
     platform: process.platform,
     arch: process.arch,
-    packageVersion: true ? "0.2.1-beta-8ae7a0d300-260807161635" : "unknown",
+    packageVersion: true ? "0.2.1" : "unknown",
     sensitiveContentIncluded: options.includeSensitiveContent,
     listenerAndLlmContentIncluded: true,
     credentialsAlwaysRedacted: true,
@@ -39731,7 +39948,7 @@ async function exec(args) {
     );
     logger.error(
       LogEvent.ONCHAINOS_CLI_ERROR,
-      new Error("onchainos command failed"),
+      err2 instanceof Error ? err2 : new Error("onchainos command failed"),
       {
         component: "onchainos_cli",
         source: "onchainos",
@@ -54459,6 +54676,171 @@ var init_dist4 = __esm({
   }
 });
 
+// ../core/src/xmtp-sdk/stream-recovery-telemetry.ts
+function isAgentStreamRecoveryError(error) {
+  return error instanceof Error && error.constructor.name === "AgentStreamingError" && typeof error.code === "number" && [1002, 1004, 1005].includes(error.code);
+}
+function extractStreamErrorTelemetry(error) {
+  const telemetry = {};
+  if (typeof error.code === "number" && Number.isSafeInteger(error.code)) {
+    telemetry.streamErrorCode = String(error.code);
+    const streamType = {
+      1002: "conversation",
+      1004: "message",
+      1005: "setup"
+    };
+    if (streamType[error.code]) {
+      telemetry.streamType = streamType[error.code];
+    }
+  }
+  const cause = error.cause;
+  if (!(cause instanceof Error)) {
+    return telemetry;
+  }
+  telemetry.causeMessageLength = String(cause.message.length);
+  const causeCode = cause.code;
+  if (typeof causeCode === "string" && KNOWN_CAUSE_CODES.has(causeCode)) {
+    telemetry.causeCode = causeCode;
+  }
+  const causeKind = cause.message.match(
+    /^\[([A-Za-z][A-Za-z0-9]{0,63})::([A-Za-z][A-Za-z0-9]{0,63})\]/
+  );
+  const knownCauseKind = causeKind ? KNOWN_CAUSE_KINDS.get(`${causeKind[1]}::${causeKind[2]}`) : void 0;
+  if (knownCauseKind) {
+    telemetry.causeType = knownCauseKind[0];
+    telemetry.causeVariant = knownCauseKind[1];
+  }
+  const grpcMethod = cause.message.match(
+    /endpoint\s+["']\/[A-Za-z0-9_.]+\/([A-Za-z][A-Za-z0-9_]{0,63})["']/
+  );
+  if (grpcMethod && KNOWN_GRPC_METHODS.has(grpcMethod[1])) {
+    telemetry.grpcMethod = grpcMethod[1];
+    telemetry.endpoint = grpcMethod[1];
+  }
+  if (/\bh2 protocol error\b/i.test(cause.message)) {
+    telemetry.transportProtocol = "h2";
+  }
+  const transportFailure = TRANSPORT_FAILURE_PATTERNS.find(
+    ([pattern]) => pattern.test(cause.message)
+  );
+  if (transportFailure) {
+    telemetry.transportFailure = transportFailure[1];
+    telemetry.reason = transportFailure[1];
+  }
+  return telemetry;
+}
+function createKeyedFlight(discriminator, operation) {
+  let resolve14;
+  let reject;
+  const promise = new Promise((resolvePromise, rejectPromise) => {
+    resolve14 = resolvePromise;
+    reject = rejectPromise;
+  });
+  return { discriminator, operation, promise, resolve: resolve14, reject };
+}
+var TRANSPORT_FAILURE_PATTERNS, KNOWN_CAUSE_CODES, KNOWN_CAUSE_KINDS, KNOWN_GRPC_METHODS, StreamRecoveryTelemetry, KeyedSingleFlight;
+var init_stream_recovery_telemetry = __esm({
+  "../core/src/xmtp-sdk/stream-recovery-telemetry.ts"() {
+    "use strict";
+    TRANSPORT_FAILURE_PATTERNS = [
+      [/broken\s*pipe|BrokenPipe/i, "broken_pipe"],
+      [/connection\s*reset|ConnectionReset/i, "connection_reset"],
+      [/timed?\s*out|TimedOut/i, "timeout"],
+      [/unexpected\s*eof|UnexpectedEof/i, "unexpected_eof"]
+    ];
+    KNOWN_CAUSE_CODES = /* @__PURE__ */ new Set(["GenericFailure"]);
+    KNOWN_CAUSE_KINDS = /* @__PURE__ */ new Map([
+      ["SubscribeError::BoxError", ["SubscribeError", "BoxError"]]
+    ]);
+    KNOWN_GRPC_METHODS = /* @__PURE__ */ new Set([
+      "SubscribeGroupMessages",
+      "SubscribeWelcomeMessages"
+    ]);
+    StreamRecoveryTelemetry = class {
+      nextSequence = 1;
+      activeRecovery;
+      get activeSequence() {
+        return this.activeRecovery?.sequence;
+      }
+      markError(nowMs = Date.now()) {
+        if (this.activeRecovery) {
+          return {
+            recoverySequence: this.activeRecovery.sequence,
+            alreadyRecovering: true
+          };
+        }
+        const sequence = this.nextSequence++;
+        this.activeRecovery = { sequence, startedAtMs: nowMs };
+        return { recoverySequence: sequence, alreadyRecovering: false };
+      }
+      markStarted(nowMs = Date.now()) {
+        if (!this.activeRecovery) {
+          return void 0;
+        }
+        const completed = {
+          recoverySequence: this.activeRecovery.sequence,
+          recoveryDurationMs: Math.max(0, nowMs - this.activeRecovery.startedAtMs)
+        };
+        this.activeRecovery = void 0;
+        return completed;
+      }
+      cancel() {
+        this.activeRecovery = void 0;
+      }
+    };
+    KeyedSingleFlight = class {
+      inFlight = /* @__PURE__ */ new Map();
+      run(key, discriminator, operation) {
+        const normalizedKey = key.toLowerCase();
+        const state = this.inFlight.get(normalizedKey);
+        if (!state) {
+          const active = createKeyedFlight(discriminator, operation);
+          this.inFlight.set(normalizedKey, { active, queued: [] });
+          this.execute(normalizedKey, active);
+          return active.promise;
+        }
+        if (state.active.discriminator === discriminator) {
+          return state.active.promise;
+        }
+        const queued = state.queued.find(
+          (flight2) => flight2.discriminator === discriminator
+        );
+        if (queued) {
+          return queued.promise;
+        }
+        const flight = createKeyedFlight(discriminator, operation);
+        state.queued.push(flight);
+        return flight.promise;
+      }
+      execute(key, flight) {
+        void Promise.resolve().then(flight.operation).then(
+          (value) => {
+            flight.resolve(value);
+            this.advance(key, flight);
+          },
+          (error) => {
+            flight.reject(error);
+            this.advance(key, flight);
+          }
+        );
+      }
+      advance(key, completed) {
+        const state = this.inFlight.get(key);
+        if (state?.active !== completed) {
+          return;
+        }
+        const next = state.queued.shift();
+        if (!next) {
+          this.inFlight.delete(key);
+          return;
+        }
+        state.active = next;
+        this.execute(key, next);
+      }
+    };
+  }
+});
+
 // ../core/src/xmtp-sdk/extract-job-id.ts
 function extractJobIdFromContent(content2) {
   const raw = typeof content2 === "string" ? content2 : stringifyJsonForEnvelope(content2);
@@ -55262,6 +55644,12 @@ function parseGroupPayload(content2) {
 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 createOfflineReplayAddressSummary(address) {
   return {
     address,
@@ -55279,7 +55667,7 @@ function createOfflineReplayAddressSummary(address) {
     durationMs: 0
   };
 }
-var import_node_fs22, import_node_path26, DEFAULT_DATA_DIR, XMTP_INSTALLATION_WARNING_THRESHOLD, XMTP_INSTALLATION_NEAR_LIMIT_THRESHOLD, SENSITIVE_WORDS_LAZY_RETRY_COOLDOWN_MS, SESSION_EXPIRED_RE, InboundReplayGate, SYSTEM_CONFIG_DEFAULTS, SEMVER_RE, isRecord5, isPositiveNumber, SYSTEM_CONFIG_VALIDATORS, XmtpService;
+var import_node_fs22, import_node_path26, DEFAULT_DATA_DIR, XMTP_INSTALLATION_WARNING_THRESHOLD, XMTP_INSTALLATION_NEAR_LIMIT_THRESHOLD, SENSITIVE_WORDS_LAZY_RETRY_COOLDOWN_MS, SESSION_EXPIRED_RE, InboundReplayGate, SYSTEM_CONFIG_DEFAULTS, STREAM_RECOVERY_ALERT_THRESHOLD_MS, REPLAY_GATE_DRAIN_MAX_ATTEMPTS, REPLAY_GATE_DRAIN_RETRY_DELAY_MS, SEMVER_RE, isRecord5, isPositiveNumber, SYSTEM_CONFIG_VALIDATORS, XmtpService;
 var init_xmtp_sdk = __esm({
   "../core/src/xmtp-sdk/index.ts"() {
     "use strict";
@@ -55289,6 +55677,7 @@ var init_xmtp_sdk = __esm({
     init_dist4();
     init_dist2();
     init_sentry_logger();
+    init_stream_recovery_telemetry();
     init_extract_job_id();
     init_self_filter();
     init_logging();
@@ -55306,10 +55695,11 @@ var init_xmtp_sdk = __esm({
         this.inbound = inbound;
       }
       inbound;
-      buffering = true;
+      holds = 1;
       queue = [];
+      drainInFlight;
       middleware = async (ctx, next) => {
-        if (!this.buffering) {
+        if (this.holds === 0 && !this.drainInFlight) {
           await this.inbound(ctx, next);
           return;
         }
@@ -55318,19 +55708,55 @@ var init_xmtp_sdk = __esm({
       get bufferedCount() {
         return this.queue.length;
       }
+      abandonFailedAndRelease() {
+        const abandoned = this.queue.length > 0 ? 1 : 0;
+        if (abandoned > 0) {
+          this.queue.shift();
+        }
+        if (this.holds > 0) {
+          this.holds--;
+        }
+        return abandoned;
+      }
+      hold() {
+        this.holds++;
+      }
       async drain() {
+        if (this.holds > 0) {
+          this.holds--;
+        }
+        return this.drainReleased();
+      }
+      async drainReleased() {
+        if (this.holds > 0) {
+          return 0;
+        }
+        if (this.drainInFlight) {
+          return this.drainInFlight;
+        }
+        const drain = Promise.resolve().then(() => this.drainQueue());
+        this.drainInFlight = drain;
+        try {
+          return await drain;
+        } finally {
+          if (this.drainInFlight === drain) {
+            this.drainInFlight = void 0;
+          }
+        }
+      }
+      async drainQueue() {
         let drained = 0;
-        while (this.queue.length > 0) {
+        while (this.holds === 0 && this.queue.length > 0) {
           const item = this.queue.shift();
           try {
             await this.inbound(item.ctx, item.next);
           } catch (err2) {
             this.queue.unshift(item);
+            this.holds++;
             throw err2;
           }
           drained++;
         }
-        this.buffering = false;
         return drained;
       }
     };
@@ -55346,6 +55772,9 @@ var init_xmtp_sdk = __esm({
         }
       }
     };
+    STREAM_RECOVERY_ALERT_THRESHOLD_MS = 3e4;
+    REPLAY_GATE_DRAIN_MAX_ATTEMPTS = 3;
+    REPLAY_GATE_DRAIN_RETRY_DELAY_MS = 100;
     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-]+)*)?$/;
     isRecord5 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
     isPositiveNumber = (value) => typeof value === "number" && Number.isFinite(value) && value > 0;
@@ -55390,7 +55819,15 @@ var init_xmtp_sdk = __esm({
       };
       dataDir = DEFAULT_DATA_DIR;
       syncByAddress = /* @__PURE__ */ new Map();
+      offlineReplaySingleFlight = new KeyedSingleFlight();
       inboundReplayGates = /* @__PURE__ */ new Map();
+      streamRecoveryCleanupByAddress = /* @__PURE__ */ new Map();
+      nextClientGeneration = 1;
+      clientGenerationByClient = /* @__PURE__ */ new WeakMap();
+      resolveStartupReplayCompletion;
+      startupReplayCompletion = new Promise((resolve14) => {
+        this.resolveStartupReplayCompletion = resolve14;
+      });
       agentListFingerprint;
       // Only one refreshAgents can be in flight at a time; concurrent calls
       // coalesce onto the same promise. This avoids duplicate Agent.create()
@@ -55845,6 +56282,7 @@ var init_xmtp_sdk = __esm({
           const client = this.clients.get(address);
           if (client) {
             try {
+              this.cancelStreamRecoveryForAddress(address);
               this.stoppedAddresses.add(address.toLowerCase());
               client.stop();
               logWithTimestamp(
@@ -56018,7 +56456,16 @@ var init_xmtp_sdk = __esm({
               logWithTimestamp(
                 `[xmtp-sdk] refresh: ${address} has a prior sync timestamp, triggering offline replay`
               );
-              void this.replayOfflineMessagesForAddress(address, "agent_refresh").catch((err2) => {
+              const expectedClient = this.clients.get(address) ?? null;
+              const expectedGate = this.inboundReplayGates.get(
+                address.toLowerCase()
+              );
+              void this.replayOfflineMessagesForAddressSingleFlight(
+                address,
+                "agent_refresh",
+                void 0,
+                expectedClient
+              ).catch((err2) => {
                 logWithTimestamp(`[xmtp-sdk] refresh: ${address} offline replay failed:`, err2);
                 logger.error(
                   LogEvent.OFFLINE_REPLAY_FAILED,
@@ -56028,7 +56475,7 @@ var init_xmtp_sdk = __esm({
                     stage: "refreshAgents/replay"
                   }
                 );
-              }).then(() => this.drainInboundReplayGate(address)).catch((err2) => {
+              }).then(() => this.drainInboundReplayGate(address, expectedGate)).catch((err2) => {
                 logWithTimestamp(`[xmtp-sdk] refresh: ${address} replay gate drain failed:`, err2);
               });
             }
@@ -56060,6 +56507,7 @@ var init_xmtp_sdk = __esm({
           }
           const addressKey = address.toLowerCase();
           try {
+            this.cancelStreamRecoveryForAddress(address);
             this.stoppedAddresses.add(addressKey);
             await Promise.resolve(oldClient.stop());
             this.clients.delete(address);
@@ -56116,11 +56564,17 @@ var init_xmtp_sdk = __esm({
               phase: "recycle"
             });
             await this.startListeningForAddresses([address]);
+            const replayGate = this.inboundReplayGates.get(addressKey);
             let replaySummary;
             try {
-              replaySummary = await this.replayOfflineMessagesForAddress(address, "client_recycle");
+              replaySummary = await this.replayOfflineMessagesForAddressSingleFlight(
+                address,
+                "client_recycle",
+                void 0,
+                agent
+              );
             } finally {
-              await this.drainInboundReplayGate(address);
+              await this.drainInboundReplayGate(address, replayGate);
             }
             addresses.push(replaySummary);
             replayed += replaySummary.replayed;
@@ -56128,6 +56582,7 @@ var init_xmtp_sdk = __esm({
             recycled++;
           } catch (err2) {
             failed++;
+            this.cancelStreamRecoveryForAddress(address);
             this.clients.delete(address);
             logWithTimestamp(`[xmtp-sdk] recycle: failed to recreate client: ${address}`, err2);
             logger.error(
@@ -56528,16 +56983,83 @@ var init_xmtp_sdk = __esm({
       async startListening() {
         await this.startListeningForAddresses([...this.clients.keys()]);
       }
-      async drainInboundReplayGate(address) {
+      async drainInboundReplayGate(address, expectedGate) {
+        if (!expectedGate) {
+          return 0;
+        }
         const gate = this.inboundReplayGates.get(address.toLowerCase());
-        if (!gate) {
+        if (!gate || gate !== expectedGate) {
           return 0;
         }
-        const drained = await gate.drain();
+        let attempt = 0;
+        let totalDrained = 0;
+        let releaseHold = true;
+        while (true) {
+          try {
+            const drained = releaseHold ? await gate.drain() : await gate.drainReleased();
+            totalDrained += drained;
+            logWithTimestamp(
+              `[xmtp-sdk:${address}] replay barrier released, buffered=${totalDrained} attempt=${attempt + 1}`
+            );
+            return totalDrained;
+          } catch (err2) {
+            attempt++;
+            logWithTimestamp(
+              `[xmtp-sdk:${address}] replay barrier drain failed attempt=${attempt}/${REPLAY_GATE_DRAIN_MAX_ATTEMPTS}:`,
+              err2
+            );
+            if (attempt < REPLAY_GATE_DRAIN_MAX_ATTEMPTS) {
+              releaseHold = true;
+              await new Promise(
+                (resolve14) => setTimeout(resolve14, REPLAY_GATE_DRAIN_RETRY_DELAY_MS * attempt)
+              );
+              continue;
+            }
+            const abandoned = gate.abandonFailedAndRelease();
+            logger.error(
+              LogEvent.INBOUND_REPLAY_GATE_DRAIN_FAILED,
+              err2 instanceof Error ? err2 : void 0,
+              {
+                walletAddress: address,
+                attemptCount: String(REPLAY_GATE_DRAIN_MAX_ATTEMPTS),
+                abandonedCount: String(abandoned),
+                stage: "inboundReplayGate/fail-open",
+                reason: "drain_retry_exhausted"
+              }
+            );
+            logWithTimestamp(
+              `[xmtp-sdk:${address}] replay barrier fail-open after ${REPLAY_GATE_DRAIN_MAX_ATTEMPTS} failed attempts, abandoned=${abandoned}`
+            );
+            attempt = 0;
+            releaseHold = false;
+          }
+        }
+      }
+      holdInboundReplayGate(address) {
+        const gate = this.inboundReplayGates.get(address.toLowerCase());
+        if (!gate) {
+          return void 0;
+        }
+        gate.hold();
         logWithTimestamp(
-          `[xmtp-sdk:${address}] startup replay barrier opened, buffered=${drained}`
+          `[xmtp-sdk:${address}] replay barrier held, buffered=${gate.bufferedCount}`
         );
-        return drained;
+        return gate;
+      }
+      cancelStreamRecoveryForAddress(address) {
+        const addressKey = address.toLowerCase();
+        const cleanup = this.streamRecoveryCleanupByAddress.get(addressKey);
+        this.streamRecoveryCleanupByAddress.delete(addressKey);
+        cleanup?.();
+      }
+      getClientGeneration(client) {
+        const existing = this.clientGenerationByClient.get(client);
+        if (existing !== void 0) {
+          return existing;
+        }
+        const generation = this.nextClientGeneration++;
+        this.clientGenerationByClient.set(client, generation);
+        return generation;
       }
       notifyAgentsWakeupAfterReplay() {
         const notifyAgentsWakeup2 = this.tools.notifyAgentsWakeup;
@@ -56571,10 +57093,18 @@ var init_xmtp_sdk = __esm({
        * cannot overtake the stored backlog.
        */
       async completeStartupReplay() {
+        const startupGates = new Map(
+          [...this.clients.keys()].map((address) => [
+            address,
+            this.inboundReplayGates.get(address.toLowerCase())
+          ])
+        );
         const summary = await this.replayOfflineMessages("startup");
-        for (const address of this.clients.keys()) {
-          await this.drainInboundReplayGate(address);
+        for (const [address, expectedGate] of startupGates) {
+          await this.drainInboundReplayGate(address, expectedGate);
         }
+        this.resolveStartupReplayCompletion?.();
+        this.resolveStartupReplayCompletion = void 0;
         this.notifyAgentsWakeupAfterReplay();
         return summary;
       }
@@ -56582,6 +57112,8 @@ var init_xmtp_sdk = __esm({
         const valid = addresses.filter((addr) => this.clients.has(addr));
         await parallelMap(valid, async (address) => {
           const agent = this.clients.get(address);
+          const clientGeneration = this.getClientGeneration(agent);
+          const addressKey = address.toLowerCase();
           const tag = `[xmtp-sdk:${address}]`;
           const onchainosAgent = this.getAgentByAddress(address);
           const identity = {
@@ -56684,14 +57216,131 @@ var init_xmtp_sdk = __esm({
             logWithTimestamp(`${tag} reconnecting in ${delay}ms (attempt=${attempt + 1})`);
             setTimeout(() => void startWithRetry(attempt + 1), delay);
           };
+          const streamRecovery = new StreamRecoveryTelemetry();
+          let recoveryTimeout;
+          let pendingRecoveryGate;
+          let recoveryDisposed = false;
+          this.cancelStreamRecoveryForAddress(address);
+          const cleanupStreamRecovery = () => {
+            recoveryDisposed = true;
+            streamRecovery.cancel();
+            if (recoveryTimeout) {
+              clearTimeout(recoveryTimeout);
+              recoveryTimeout = void 0;
+            }
+          };
+          this.streamRecoveryCleanupByAddress.set(
+            addressKey,
+            cleanupStreamRecovery
+          );
           agent.on("unhandledError", (err2) => {
+            if (recoveryDisposed || this.clients.get(address) !== agent || this.stoppedAddresses.has(addressKey)) {
+              return;
+            }
+            if (!isAgentStreamRecoveryError(err2)) {
+              logWithTimestamp(`${tag} agent unhandled error:`, err2);
+              logger.error(LogEvent.AGENT_UNHANDLED_ERROR, err2, agentExtras(identity));
+              return;
+            }
+            const recovery = streamRecovery.markError();
+            const errorTelemetry = extractStreamErrorTelemetry(err2);
+            if (!recovery.alreadyRecovering) {
+              pendingRecoveryGate = this.holdInboundReplayGate(address);
+            }
             logWithTimestamp(`${tag} agent stream error:`, err2);
-            logger.error(LogEvent.AGENT_STREAM_ERROR, err2, agentExtras(identity));
+            logger.info(LogEvent.AGENT_STREAM_ERROR, {
+              ...agentExtras(identity),
+              ...errorTelemetry,
+              clientGeneration: String(clientGeneration),
+              recoverySequence: String(recovery.recoverySequence),
+              recoveryAlreadyActive: String(recovery.alreadyRecovering)
+            });
+            if (!recovery.alreadyRecovering) {
+              recoveryTimeout = setTimeout(() => {
+                if (recoveryDisposed || this.clients.get(address) !== agent || this.stoppedAddresses.has(addressKey) || streamRecovery.activeSequence !== recovery.recoverySequence) {
+                  return;
+                }
+                logger.error(LogEvent.AGENT_STREAM_RECOVERY_TIMEOUT, void 0, {
+                  ...agentExtras(identity),
+                  ...errorTelemetry,
+                  clientGeneration: String(clientGeneration),
+                  recoverySequence: String(recovery.recoverySequence),
+                  recoveryDurationMs: String(STREAM_RECOVERY_ALERT_THRESHOLD_MS),
+                  thresholdMs: String(STREAM_RECOVERY_ALERT_THRESHOLD_MS)
+                });
+              }, STREAM_RECOVERY_ALERT_THRESHOLD_MS);
+            }
           });
           agent.on("start", () => {
+            if (recoveryDisposed || this.clients.get(address) !== agent || this.stoppedAddresses.has(addressKey)) {
+              return;
+            }
+            const recovery = streamRecovery.markStarted();
+            if (recoveryTimeout) {
+              clearTimeout(recoveryTimeout);
+              recoveryTimeout = void 0;
+            }
             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 (!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)
+                    });
+                  }
+                } catch (err2) {
+                  logWithTimestamp(`${tag} recovery offline replay failed:`, err2);
+                  logger.error(
+                    LogEvent.OFFLINE_REPLAY_FAILED,
+                    err2 instanceof Error ? err2 : new Error(String(err2)),
+                    {
+                      ...agentExtras(identity),
+                      clientGeneration: String(clientGeneration),
+                      recoverySequence: String(recovery.recoverySequence),
+                      stage: "streamRecovery/replay"
+                    }
+                  );
+                } finally {
+                  try {
+                    await this.drainInboundReplayGate(address, recoveryGate);
+                  } catch (err2) {
+                    logWithTimestamp(`${tag} recovery replay gate drain failed:`, err2);
+                    logger.error(
+                      LogEvent.OFFLINE_REPLAY_FAILED,
+                      err2 instanceof Error ? err2 : new Error(String(err2)),
+                      {
+                        ...agentExtras(identity),
+                        clientGeneration: String(clientGeneration),
+                        recoverySequence: String(recovery.recoverySequence),
+                        stage: "streamRecovery/drain-gate"
+                      }
+                    );
+                  }
+                }
+              })();
+            }
             if (process.env.XMTP_FORCE_DEBUG === "true") {
               void logDetails(agent).catch((err2) => {
                 logWithTimestamp(`${tag} agent debug details failed:`, err2);
@@ -56709,12 +57358,12 @@ var init_xmtp_sdk = __esm({
           logWithTimestamp(`${tag} message listener started`);
         });
       }
-      async replayOfflineMessagesForAddress(address, trigger = "periodic_repair") {
+      async replayOfflineMessagesForAddress(address, expectedClient, trigger = "periodic_repair") {
         const addressReplayStartedAt = Date.now();
         const summary = createOfflineReplayAddressSummary(address);
         const isOfflineReplay = isOfflineReplayForTrigger(trigger);
         const agent = this.clients.get(address);
-        if (!agent) {
+        if (!agent || agent !== expectedClient) {
           summary.durationMs = Date.now() - addressReplayStartedAt;
           return summary;
         }
@@ -56919,6 +57568,35 @@ var init_xmtp_sdk = __esm({
         );
         return summary;
       }
+      replayOfflineMessagesForAddressSingleFlight(address, trigger = "periodic_repair", recoveryIdentity, expectedClient = this.clients.get(address) ?? null) {
+        const clientGeneration = expectedClient ? this.getClientGeneration(expectedClient) : "missing";
+        const eligibilityClass = replaySingleFlightDiscriminator(
+          trigger,
+          clientGeneration,
+          recoveryIdentity
+        );
+        return this.offlineReplaySingleFlight.run(
+          address,
+          eligibilityClass,
+          async () => {
+            await this._backupReady;
+            return this.replayOfflineMessagesForAddress(
+              address,
+              expectedClient,
+              trigger
+            );
+          }
+        );
+      }
+      async replayOfflineMessagesForStreamRecovery(address, recoveryIdentity, expectedClient) {
+        await this.startupReplayCompletion;
+        return this.replayOfflineMessagesForAddressSingleFlight(
+          address,
+          "stream_recovery",
+          recoveryIdentity,
+          expectedClient
+        );
+      }
       async replayOfflineMessages(trigger = "periodic_repair") {
         await this._backupReady;
         const replayStartedAt = Date.now();
@@ -56926,7 +57604,10 @@ var init_xmtp_sdk = __esm({
         let totalSkipped = 0;
         const addresses = [];
         for (const address of this.clients.keys()) {
-          const summary2 = await this.replayOfflineMessagesForAddress(address, trigger);
+          const summary2 = await this.replayOfflineMessagesForAddressSingleFlight(
+            address,
+            trigger
+          );
           addresses.push(summary2);
           const { replayed, skipped: skipped2 } = summary2;
           totalReplayed += replayed;
@@ -65447,12 +66128,12 @@ async function runListenerWithLock(options, paths) {
       });
     }
   });
-  service.setPluginVersion("0.2.1-beta-8ae7a0d300-260807161635");
+  service.setPluginVersion("0.2.1");
   await service.init();
   const pluginVersionStatus = service.pluginVersionStatus;
   if (pluginVersionStatus.unavailable) {
     throw new Error(
-      `@okxweb3/a2a-node v${"0.2.1-beta-8ae7a0d300-260807161635"} is below the required minimum v${pluginVersionStatus.minVersion}`
+      `@okxweb3/a2a-node v${"0.2.1"} is below the required minimum v${pluginVersionStatus.minVersion}`
     );
   }
   const systemConfig = service.getSystemConfig();
@@ -65470,7 +66151,7 @@ async function runListenerWithLock(options, paths) {
       onchainosAgentId: "*",
       reason: "system-config missing sentryDsn",
       pluginId: "@okxweb3/a2a-node",
-      pluginVersion: "0.2.1-beta-8ae7a0d300-260807161635"
+      pluginVersion: "0.2.1"
     });
   }
   logWithTimestamp(
@@ -66138,6 +66819,7 @@ function summarizeXmtpTestEvents(runId, events) {
   const nodeDurations = /* @__PURE__ */ new Map();
   const replayLags = /* @__PURE__ */ new Map();
   const replayHandles = /* @__PURE__ */ new Map();
+  const streamRecoveries = /* @__PURE__ */ new Map();
   const agentMap = /* @__PURE__ */ new Map();
   for (const event of events) {
     const key = deliveryKey(event);
@@ -66170,6 +66852,18 @@ function summarizeXmtpTestEvents(runId, events) {
         event.handlerTotalMs
       );
     }
+    if (event.eventName === "Agent stream recovered") {
+      setDuration(
+        streamRecoveries,
+        [
+          eventAgentId(event),
+          stringValue(event.clientGeneration) || "unknown-client",
+          stringValue(event.recoverySequence) || "unknown-recovery",
+          event.timestamp
+        ].join(":"),
+        event.recoveryDurationMs
+      );
+    }
   }
   const agents = [...agentMap.entries()].filter(([, value]) => value.live.size > 0 || value.replay.size > 0).map(([agentId, value]) => {
     const total = (/* @__PURE__ */ new Set([...value.live, ...value.replay])).size;
@@ -66191,7 +66885,9 @@ function summarizeXmtpTestEvents(runId, events) {
     duplicateEvents: countEvent(events, "Inbound ignored: duplicate message"),
     replayMessageFailures: countEvent(events, "Offline replay message failed"),
     replayScanFailures: countEvent(events, "Offline replay failed"),
-    streamFailures: countEvent(events, "conversations.stream failed") + countEvent(events, "Agent stream error"),
+    streamFailures: countEvent(events, "conversations.stream failed") + countEvent(events, "agent stream error"),
+    streamRecoveries: countEvent(events, "Agent stream recovered"),
+    streamRecoveryTimeouts: countEvent(events, "Agent stream recovery timeout"),
     connectionFailures: countEvent(events, "XMTP connection failed"),
     successfulReplayScans: countEvent(events, "Address sync completed"),
     replayScansWithMessages: events.filter((event) => event.eventName === "Address sync completed" && numericValue(event.replayed) > 0).length,
@@ -66199,6 +66895,7 @@ function summarizeXmtpTestEvents(runId, events) {
     nodeHandlerMs: summarizeDurations([...nodeDurations.values()]),
     replayLagMs: summarizeDurations([...replayLags.values()]),
     replayHandleMs: summarizeDurations([...replayHandles.values()]),
+    streamRecoveryMs: summarizeDurations([...streamRecoveries.values()]),
     agents
   };
 }
@@ -66213,6 +66910,8 @@ Reliability
   Replay message failures      ${summary.replayMessageFailures}
   Replay scan failures         ${summary.replayScanFailures}
   Stream failures              ${summary.streamFailures}
+  Stream recoveries            ${summary.streamRecoveries}
+  Recovery timeouts (>30s)     ${summary.streamRecoveryTimeouts}
   XMTP connection failures     ${summary.connectionFailures}
   Replay scans                 ${summary.successfulReplayScans}
   Scans with replay            ${summary.replayScansWithMessages}
@@ -66221,7 +66920,8 @@ Timing
   XMTP delivery p50/p95/max    ${formatDurationSummary(summary.xmtpDeliveryMs)}
   Node handler p50/p95/max     ${formatDurationSummary(summary.nodeHandlerMs)}
   Replay lag p50/p95/max       ${formatDurationSummary(summary.replayLagMs)}
-  Replay handler p50/p95/max   ${formatDurationSummary(summary.replayHandleMs)}`);
+  Replay handler p50/p95/max   ${formatDurationSummary(summary.replayHandleMs)}
+  Stream recovery p50/p95/max  ${formatDurationSummary(summary.streamRecoveryMs)}`);
   if (summary.agents.length > 0) {
     console.log("\nAgents");
     for (const agent of summary.agents) {
@@ -113550,7 +114250,7 @@ async function getCurrentNodeCliVersion() {
   return await getGlobalNpmPackageVersion(UPDATE_PACKAGES.node) ?? getBundledNodeCliVersion();
 }
 function getBundledNodeCliVersion() {
-  return true ? "0.2.1-beta-8ae7a0d300-260807161635" : null;
+  return true ? "0.2.1" : null;
 }
 function readConfiguredAiProvider() {
   const explicit = process.env.OKX_A2A_AI_PROVIDER || process.env.OKX_AGENT_TASK_AI_CLI;
@@ -113760,7 +114460,7 @@ async function updateHermes(release, options) {
   }
 }
 async function installGatewayPluginForDoctor(target) {
-  const release = isPrereleaseVersion("0.2.1-beta-8ae7a0d300-260807161635") ? "beta" : "latest";
+  const release = isPrereleaseVersion("0.2.1") ? "beta" : "latest";
   const insideTargetGateway = detectGatewayInvocation() === target;
   const options = {
     restart: !insideTargetGateway,
@@ -114748,7 +115448,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.1-beta-8ae7a0d300-260807161635" : "0.0.0"),
+    cliVersion: options.cliVersion ?? (true ? "0.2.1" : "0.0.0"),
     fixMode: options.fix === true,
     nonInteractive: options.nonInteractive === true,
     packageChanged: false,
@@ -115716,7 +116416,7 @@ init_sentry_logger();
 init_sentry_config();
 var CURRENT_GATEWAY_SESSION_KEYS_ENV4 = "OKX_A2A_CURRENT_GATEWAY_SESSION_KEYS";
 function printUsage3() {
-  console.log(`okx-a2a ${"0.2.1-beta-8ae7a0d300-260807161635"}
+  console.log(`okx-a2a ${"0.2.1"}
 
 Usage:
   okx-a2a <command> [options]
@@ -115756,7 +116456,7 @@ Run \`okx-a2a <command> -h\` for command-specific help.
 `);
 }
 function printVersion() {
-  console.log("0.2.1-beta-8ae7a0d300-260807161635");
+  console.log("0.2.1");
 }
 function printDaemonUsage() {
   console.log(`Usage: okx-a2a daemon <start|restart|stop|status|autostart> [options]
@@ -117167,7 +117867,7 @@ 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.1-beta-8ae7a0d300-260807161635",
+      packageVersion: "0.2.1",
       agentSdkVersion: "2.3.0",
       nodeSdkVersion: "6.1.0",
       nodeBindingsVersion: "1.11.0"