@okxweb3/a2a-node 0.2.10-beta-1a0d85b27f-260828092722 → 0.2.10

package/dist/cli.js

@@ -26934,7 +26934,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     client: {
       id: "gateway-client",
       displayName: "okx-a2a-node",
-      version: "0.2.10-beta-1a0d85b27f-260828092722",
+      version: "0.2.10",
       platform: "node",
       mode: "backend",
       instanceId
@@ -26945,7 +26945,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     commands: [],
     permissions: {},
     locale: Intl.DateTimeFormat().resolvedOptions().locale || "en-US",
-    userAgent: `okx-a2a-node/${"0.2.10-beta-1a0d85b27f-260828092722"}`,
+    userAgent: `okx-a2a-node/${"0.2.10"}`,
     auth: {
       ...config.token ? { token: config.token } : {},
       ...config.password ? { password: config.password } : {}
@@ -29004,7 +29004,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.10-beta-1a0d85b27f-260828092722",
+      release: "0.2.10",
       environment,
       runtimeContainer: normalizeRuntimeContainer(process.env.OKX_A2A_RUNTIME_CONTAINER)
     };
@@ -40174,7 +40174,7 @@ async function exportDiagnosticLogs(options) {
     node: process.version,
     platform: process.platform,
     arch: process.arch,
-    packageVersion: true ? "0.2.10-beta-1a0d85b27f-260828092722" : "unknown",
+    packageVersion: true ? "0.2.10" : "unknown",
     sensitiveContentIncluded: options.includeSensitiveContent,
     listenerAndLlmContentIncluded: true,
     credentialsAlwaysRedacted: true,
@@ -41106,13 +41106,11 @@ async function refreshOnchainosVersionMetadata(options = {}) {
   if (versionProbeInFlight) {
     return versionProbeInFlight;
   }
-  versionProbeInFlight = (async () => {
+  const probe = (async () => {
     const observedAtMs = now();
     try {
-      const bin = await resolve9(
-        options.resolveTimeoutMs ?? ONCHAINOS_BIN_RESOLVE_TIMEOUT_MS
-      );
-      const output5 = options.runVersionCommand ? await options.runVersionCommand(bin) : await runVersionCommand(bin);
+      const resolveTimeoutMs = options.resolveTimeoutMs ?? ONCHAINOS_BIN_RESOLVE_TIMEOUT_MS;
+      const output5 = options.runVersionCommand ? await options.runVersionCommand(await resolve9(resolveTimeoutMs)) : await runVersionCommand(resolveTimeoutMs);
       const version3 = parseOnchainosVersionOutput(output5);
       if (version3 === UNKNOWN_RUNTIME_METADATA) {
         throw new Error("OnchainOS version output did not contain a semantic version");
@@ -41163,68 +41161,311 @@ async function refreshOnchainosVersionMetadata(options = {}) {
         probeStatus: "failed",
         changed: false
       };
-    } finally {
-      versionProbeInFlight = null;
     }
   })();
-  return versionProbeInFlight;
+  versionProbeInFlight = probe;
+  const clearProbe = () => {
+    if (versionProbeInFlight === probe) {
+      versionProbeInFlight = null;
+    }
+  };
+  void probe.then(clearProbe, clearProbe);
+  return probe;
+}
+async function runVersionCommand(resolveTimeoutMs) {
+  let excludedAttempt;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const selection = await resolveBinSelection(
+      resolveTimeoutMs,
+      excludedAttempt
+    );
+    const { bin } = selection;
+    const invocation = toWindowsInvocation(bin, ["--version"]);
+    try {
+      const result = await execFileAsync2(invocation.command, invocation.args, {
+        windowsHide: true,
+        windowsVerbatimArguments: invocation.windowsVerbatimArguments,
+        timeout: ONCHAINOS_VERSION_PROBE_TIMEOUT_MS
+      });
+      rememberSuccessfulBareBin(bin);
+      return [result.stdout, result.stderr].filter(Boolean).join("\n");
+    } catch (err2) {
+      if (attempt === 0 && isCommandUnavailableError(err2)) {
+        invalidateResolvedBin(
+          bin,
+          "version probe could not launch the cached binary",
+          selection.revision
+        );
+        if (shouldRetryUnavailableBin(bin)) {
+          excludedAttempt = selection;
+          continue;
+        }
+      }
+      throw err2;
+    }
+  }
+  throw new Error("OnchainOS version command retry exhausted");
 }
-async function runVersionCommand(bin) {
-  const invocation = toWindowsInvocation(bin, ["--version"]);
-  const result = await execFileAsync2(invocation.command, invocation.args, {
-    windowsHide: true,
-    windowsVerbatimArguments: invocation.windowsVerbatimArguments,
-    timeout: ONCHAINOS_VERSION_PROBE_TIMEOUT_MS
+function configuredEnvBin() {
+  return process.env.ONCHAINOS_BIN?.trim() || null;
+}
+function isPathLikeCommand(command) {
+  return command.includes("/") || command.includes("\\");
+}
+function isResolvedBinUsable(bin) {
+  if (!isPathLikeCommand(bin)) {
+    return true;
+  }
+  return process.platform === "win32" ? (0, import_node_fs20.existsSync)(bin) : isExecutable2(bin);
+}
+function resolvePosixBareCommand(command, pathValue) {
+  for (const dir of pathValue.split(":")) {
+    const candidate = (0, import_node_path24.join)(dir || ".", command);
+    if (isExecutable2(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveConfiguredBin(bin) {
+  if (isPathLikeCommand(bin)) {
+    return isResolvedBinUsable(bin) ? bin : null;
+  }
+  if (process.platform === "win32") {
+    return resolveWin32BareCommandCandidate(
+      bin,
+      process.env.PATH ?? process.env.Path ?? "",
+      process.env.PATHEXT ?? process.env.PathExt ?? ".COM;.EXE;.BAT;.CMD",
+      process.env.USERPROFILE
+    );
+  }
+  return resolvePosixBareCommand(bin, process.env.PATH ?? "");
+}
+function cacheResolvedBin(bin, envBin) {
+  resolvedBin = bin;
+  resolvedForEnvBin = envBin;
+  resolverRevision += 1;
+  return { bin, revision: resolverRevision };
+}
+function rememberSuccessfulBareBin(bin) {
+  if (process.platform !== "win32" && resolvedBin === null && !isPathLikeCommand(bin)) {
+    cacheResolvedBin(bin, configuredEnvBin());
+  }
+}
+function invalidateResolvedBin(bin, reason, expectedRevision) {
+  if (resolvedBin !== bin || expectedRevision !== void 0 && resolverRevision !== expectedRevision) {
+    return false;
+  }
+  logWithTimestamp(
+    `[onchainos] invalidating cached binary ${bin}: ${reason}; rediscovering`
+  );
+  resolvedBin = null;
+  resolvedForEnvBin = null;
+  resolverRevision += 1;
+  return true;
+}
+function isCommandUnavailableError(err2) {
+  const code = err2?.code;
+  return typeof code === "string" && COMMAND_UNAVAILABLE_CODES.has(code);
+}
+function shouldRetryUnavailableBin(bin) {
+  if (!isPathLikeCommand(bin)) {
+    return false;
+  }
+  return true;
+}
+function currentPosixDiscoveryContextKey() {
+  return JSON.stringify({
+    onchainosBin: configuredEnvBin(),
+    shell: process.env.SHELL || "/bin/bash",
+    path: process.env.PATH ?? "",
+    home: process.env.HOME ?? "",
+    zDotDir: process.env.ZDOTDIR ?? "",
+    bashEnv: process.env.BASH_ENV ?? "",
+    env: process.env.ENV ?? "",
+    cwd: process.cwd()
   });
-  return [result.stdout, result.stderr].filter(Boolean).join("\n");
 }
-async function resolve9(timeoutMs) {
+function createPosixDiscoverySnapshot(envBin, excludedBin, timeoutMs) {
+  const revision = resolverRevision;
+  const contextKey = currentPosixDiscoveryContextKey();
+  const excluded = excludedBin ?? null;
+  return {
+    revision,
+    contextKey,
+    // Exclusions represent binaries that failed to launch, so they are safe
+    // to union across callers sharing this resolver generation. Keeping them
+    // out of the key lets a late request join an ongoing recovery discovery.
+    flightKey: JSON.stringify([revision, contextKey, timeoutMs]),
+    envBin,
+    excludedBin: excluded,
+    shell: process.env.SHELL || "/bin/bash",
+    childEnv: { ...process.env }
+  };
+}
+function isPosixDiscoverySnapshotCurrent(snapshot) {
+  return resolverRevision === snapshot.revision && currentPosixDiscoveryContextKey() === snapshot.contextKey;
+}
+function getOrCreatePosixDiscovery(snapshot, remainingTimeoutMs) {
+  const existing = posixDiscoveryFlights.get(snapshot.flightKey);
+  if (existing) {
+    if (snapshot.excludedBin) {
+      existing.excludedBins.add(snapshot.excludedBin);
+    }
+    existing.joinCount += 1;
+    logWithTimestamp("[onchainos] joining in-flight binary discovery");
+    return existing;
+  }
+  const excludedBins = /* @__PURE__ */ new Set();
+  if (snapshot.excludedBin) {
+    excludedBins.add(snapshot.excludedBin);
+  }
+  const expiresAtMs = Date.now() + remainingTimeoutMs;
+  const discovery = (async () => {
+    try {
+      const { stdout } = await execFileAsync2(
+        snapshot.shell,
+        ["-lc", "command -v onchainos"],
+        {
+          env: snapshot.childEnv,
+          windowsHide: true,
+          timeout: remainingTimeoutMs
+        }
+      );
+      const bin = extractExecutablePath(stdout);
+      return bin ? { status: "found", bin } : { status: "not_found" };
+    } catch (err2) {
+      if (isPosixDiscoveryTimeoutError(err2, expiresAtMs)) {
+        logWithTimestamp(
+          "[onchainos] shell resolve timed out; callers with time remaining may retry"
+        );
+        return { status: "timed_out" };
+      }
+      logWithTimestamp(
+        "[onchainos] shell resolve failed, will fallback to bare 'onchainos':",
+        err2
+      );
+      return { status: "not_found" };
+    }
+  })();
+  const clearFlight = () => {
+    if (posixDiscoveryFlights.get(snapshot.flightKey) === flight) {
+      posixDiscoveryFlights.delete(snapshot.flightKey);
+    }
+  };
+  const flight = {
+    excludedBins,
+    expiresAtMs,
+    joinCount: 0,
+    promise: discovery.then(
+      (result) => {
+        clearFlight();
+        return result;
+      },
+      (err2) => {
+        clearFlight();
+        throw err2;
+      }
+    )
+  };
+  posixDiscoveryFlights.set(snapshot.flightKey, flight);
+  return flight;
+}
+function isPosixDiscoveryTimeoutError(err2, expiresAtMs) {
+  const timeoutError = err2;
+  return timeoutError?.killed === true || timeoutError?.code === "ETIMEDOUT" || Date.now() >= expiresAtMs;
+}
+async function resolveBinSelection(timeoutMs = ONCHAINOS_BIN_RESOLVE_TIMEOUT_MS, excludedAttempt, deadlineMs = Date.now() + timeoutMs) {
+  const excludedBin = excludedAttempt && !(resolvedBin === excludedAttempt.bin && resolverRevision !== excludedAttempt.revision) ? excludedAttempt.bin : void 0;
+  const envBin = configuredEnvBin();
+  const explicitCandidate = envBin && envBin !== excludedBin ? resolveConfiguredBin(envBin) : null;
   if (resolvedBin) {
-    return resolvedBin;
+    if (resolvedBin === excludedBin) {
+      invalidateResolvedBin(
+        resolvedBin,
+        "previous launch attempt could not start",
+        excludedAttempt?.revision
+      );
+    }
+  }
+  if (resolvedBin) {
+    const explicitBinRecovered = explicitCandidate !== null && explicitCandidate !== resolvedBin;
+    if (resolvedForEnvBin === envBin && isResolvedBinUsable(resolvedBin) && !explicitBinRecovered) {
+      return { bin: resolvedBin, revision: resolverRevision };
+    }
+    invalidateResolvedBin(
+      resolvedBin,
+      explicitBinRecovered ? "ONCHAINOS_BIN is available again" : resolvedForEnvBin !== envBin ? "ONCHAINOS_BIN changed" : "cached path is no longer executable"
+    );
   }
-  const envBin = process.env.ONCHAINOS_BIN;
   if (envBin) {
-    logWithTimestamp(`[onchainos] using ONCHAINOS_BIN=${envBin}`);
-    resolvedBin = envBin;
-    return resolvedBin;
+    if (explicitCandidate && explicitCandidate !== excludedBin) {
+      logWithTimestamp(
+        explicitCandidate === envBin ? `[onchainos] using ONCHAINOS_BIN=${envBin}` : `[onchainos] resolved ONCHAINOS_BIN=${envBin} to ${explicitCandidate}`
+      );
+      return cacheResolvedBin(explicitCandidate, envBin);
+    }
+    logWithTimestamp(
+      envBin === excludedBin ? `[onchainos] skipping ONCHAINOS_BIN=${envBin} after launch failure; falling back to discovery` : `[onchainos] ONCHAINOS_BIN is not executable at ${envBin}; falling back to discovery`
+    );
   }
   if (process.platform === "win32") {
-    const winBin = resolveWin32();
+    const winBin = resolveWin32(excludedBin);
     if (winBin) {
-      resolvedBin = winBin;
-      return resolvedBin;
+      return cacheResolvedBin(winBin, envBin);
     }
   } else {
-    try {
-      const shell = process.env.SHELL || "/bin/bash";
-      const { stdout } = await execFileAsync2(shell, ["-lc", "command -v onchainos"], {
-        windowsHide: true,
-        timeout: timeoutMs
-      });
-      const bin = extractExecutablePath(stdout);
-      if (bin) {
+    const remainingTimeoutMs = deadlineMs - Date.now();
+    if (remainingTimeoutMs > 0) {
+      const snapshot = createPosixDiscoverySnapshot(
+        envBin,
+        excludedBin,
+        timeoutMs
+      );
+      const flight = getOrCreatePosixDiscovery(snapshot, remainingTimeoutMs);
+      const discoveryResult = await flight.promise;
+      if (!isPosixDiscoverySnapshotCurrent(snapshot)) {
+        if (currentPosixDiscoveryContextKey() !== snapshot.contextKey) {
+          logWithTimestamp(
+            "[onchainos] discarding stale binary discovery result; resolver context changed"
+          );
+        }
+        return resolveBinSelection(timeoutMs, excludedAttempt, deadlineMs);
+      }
+      if (discoveryResult.status === "timed_out" && deadlineMs - Date.now() > 0) {
+        return resolveBinSelection(timeoutMs, excludedAttempt, deadlineMs);
+      }
+      const recoveredExplicitBin = snapshot.envBin ? resolveConfiguredBin(snapshot.envBin) : null;
+      if (recoveredExplicitBin && !flight.excludedBins.has(recoveredExplicitBin) && resolvedBin === null) {
+        logWithTimestamp(
+          recoveredExplicitBin === snapshot.envBin ? `[onchainos] using recovered ONCHAINOS_BIN=${snapshot.envBin}` : `[onchainos] resolved recovered ONCHAINOS_BIN=${snapshot.envBin} to ${recoveredExplicitBin}`
+        );
+        return cacheResolvedBin(recoveredExplicitBin, snapshot.envBin);
+      }
+      const bin = discoveryResult.status === "found" ? discoveryResult.bin : null;
+      if (bin && !flight.excludedBins.has(bin) && isResolvedBinUsable(bin) && resolvedBin === null) {
         logWithTimestamp(`[onchainos] resolved binary via shell: ${bin}`);
-        resolvedBin = bin;
-        return resolvedBin;
+        return cacheResolvedBin(bin, snapshot.envBin);
       }
-    } catch (err2) {
+    } else {
       logWithTimestamp(
-        "[onchainos] shell resolve failed, will fallback to bare 'onchainos':",
-        err2
+        "[onchainos] binary discovery deadline exhausted; using bare fallback"
       );
     }
   }
   logWithTimestamp(
     "[onchainos] could not resolve binary path, falling back to bare 'onchainos'"
   );
-  resolvedBin = "onchainos";
-  return resolvedBin;
+  return { bin: "onchainos", revision: resolverRevision };
 }
-function resolveWin32() {
+async function resolve9(timeoutMs = ONCHAINOS_BIN_RESOLVE_TIMEOUT_MS) {
+  return (await resolveBinSelection(timeoutMs)).bin;
+}
+function resolveWin32(excludedBin) {
   const candidates = buildWin32OnchainosCandidates(
     process.env.PATH ?? process.env.Path ?? "",
     process.env.USERPROFILE
-  );
+  ).filter((candidate) => !isSameWin32Candidate(candidate, excludedBin));
   const picked = pickOnchainosWin32Candidate(candidates);
   if (picked) {
     logWinCompat(
@@ -41237,7 +41478,14 @@ function resolveWin32() {
   );
   return null;
 }
-function buildWin32OnchainosCandidates(pathValue, userProfile) {
+function isSameWin32Candidate(candidate, excludedBin) {
+  if (!excludedBin) {
+    return false;
+  }
+  const normalize = (value) => value.replace(/\//g, "\\").replace(/\\+$/g, "").toLowerCase();
+  return normalize(candidate) === normalize(excludedBin);
+}
+function buildWin32CandidatePaths(names, pathValue, userProfile) {
   const dirs = [];
   const seen = /* @__PURE__ */ new Set();
   const addDir = (dir) => {
@@ -41257,7 +41505,6 @@ function buildWin32OnchainosCandidates(pathValue, userProfile) {
   if (userProfile?.trim()) {
     addDir((0, import_node_path24.join)(userProfile, ".local", "bin"));
   }
-  const names = ["onchainos.exe", "onchainos.cmd", "onchainos.bat", "onchainos"];
   const candidates = [];
   for (const dir of dirs) {
     for (const name of names) {
@@ -41266,6 +41513,29 @@ function buildWin32OnchainosCandidates(pathValue, userProfile) {
   }
   return candidates;
 }
+function buildWin32OnchainosCandidates(pathValue, userProfile) {
+  return buildWin32CandidatePaths(
+    ["onchainos.exe", "onchainos.cmd", "onchainos.bat", "onchainos"],
+    pathValue,
+    userProfile
+  );
+}
+function resolveWin32BareCommandCandidate(command, pathValue, pathExtValue, userProfile) {
+  const names = (0, import_node_path24.extname)(command) ? [command] : [
+    ...new Set(
+      pathExtValue.split(";").map((extension) => extension.trim().toLowerCase()).filter(Boolean).map(
+        (extension) => `${command}${extension.startsWith(".") ? extension : `.${extension}`}`
+      )
+    ),
+    command
+  ];
+  for (const candidate of buildWin32CandidatePaths(names, pathValue, userProfile)) {
+    if (win32FileExists(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
 function win32CandidatePriority(candidate) {
   const extension = (0, import_node_path24.extname)(candidate).toLowerCase();
   if (extension === ".exe") {
@@ -41370,61 +41640,81 @@ function commandForLog(bin, args) {
   return `${bin} ${redactArgsForLog(args).join(" ")}`;
 }
 async function exec(args, options = {}) {
-  const bin = await resolve9();
-  const cmd = commandForLog(bin, args);
-  logWithTimestamp(`[onchainos] exec: ${cmd}`);
-  const invocation = toWindowsInvocation(bin, args);
-  if (invocation.routedThroughWindowsShell) {
-    logWinCompat(
-      `${WIN_COMPAT_LOG_PREFIX} [onchainos] exec routed through ${invocation.command} /d /s /c: ${cmd}`
+  let excludedAttempt;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const selection = await resolveBinSelection(
+      ONCHAINOS_BIN_RESOLVE_TIMEOUT_MS,
+      excludedAttempt
     );
-  }
-  const t0 = Date.now();
-  try {
-    const result = await execFileAsync2(invocation.command, invocation.args, {
-      windowsHide: true,
-      windowsVerbatimArguments: invocation.windowsVerbatimArguments,
-      timeout: options.timeoutMs
-    });
-    logWithTimestamp(
-      `[onchainos] exec done: ${cmd} (${Date.now() - t0}ms, stdout=${result.stdout.length}B, stderr=${result.stderr.length}B)`
-    );
-    return result;
-  } catch (err2) {
+    const { bin } = selection;
+    const cmd = commandForLog(bin, args);
+    logWithTimestamp(`[onchainos] exec: ${cmd}`);
+    const invocation = toWindowsInvocation(bin, args);
     if (invocation.routedThroughWindowsShell) {
       logWinCompat(
-        `${WIN_COMPAT_LOG_PREFIX} [onchainos] routed exec failed via ${invocation.command}: ${cmd} errorCode=${err2?.code ?? ""} signal=${err2?.signal ?? ""}`
+        `${WIN_COMPAT_LOG_PREFIX} [onchainos] exec routed through ${invocation.command} /d /s /c: ${cmd}`
       );
     }
-    logWithTimestamp(
-      `[onchainos] exec error: ${cmd} (${Date.now() - t0}ms) code=${err2.code} signal=${err2.signal} killed=${err2.killed} message=${err2.message}`
-    );
-    logger.error(
-      LogEvent.ONCHAINOS_CLI_ERROR,
-      err2 instanceof Error ? err2 : new Error("onchainos command failed"),
-      {
-        component: "onchainos_cli",
-        source: "onchainos",
-        stage: "exec",
-        communicationClass: "onchainos_cli_or_api_issue",
-        operation: redactArgsForLog(args).slice(0, 3).join(" "),
-        reason: "exec_failed",
-        argCount: String(args.length),
-        exitCode: String(err2?.code ?? ""),
-        signal: String(err2?.signal ?? ""),
-        killed: String(err2?.killed ?? ""),
-        stderrBytes: String(Buffer.byteLength(String(err2?.stderr ?? ""), "utf8")),
-        stdoutBytes: String(Buffer.byteLength(String(err2?.stdout ?? ""), "utf8")),
-        cliErrorName: err2 instanceof Error ? err2.name : "",
-        cliErrorMessageLength: String(String(err2?.message ?? "").length),
-        durationMs: String(Date.now() - t0),
-        timeoutMs: String(options.timeoutMs ?? "")
+    const t0 = Date.now();
+    try {
+      const result = await execFileAsync2(invocation.command, invocation.args, {
+        windowsHide: true,
+        windowsVerbatimArguments: invocation.windowsVerbatimArguments,
+        timeout: options.timeoutMs
+      });
+      rememberSuccessfulBareBin(bin);
+      logWithTimestamp(
+        `[onchainos] exec done: ${cmd} (${Date.now() - t0}ms, stdout=${result.stdout.length}B, stderr=${result.stderr.length}B)`
+      );
+      return result;
+    } catch (err2) {
+      if (invocation.routedThroughWindowsShell) {
+        logWinCompat(
+          `${WIN_COMPAT_LOG_PREFIX} [onchainos] routed exec failed via ${invocation.command}: ${cmd} errorCode=${err2?.code ?? ""} signal=${err2?.signal ?? ""}`
+        );
       }
-    );
-    throw err2;
+      logWithTimestamp(
+        `[onchainos] exec error: ${cmd} (${Date.now() - t0}ms) code=${err2.code} signal=${err2.signal} killed=${err2.killed} message=${err2.message}`
+      );
+      if (attempt === 0 && isCommandUnavailableError(err2)) {
+        invalidateResolvedBin(
+          bin,
+          "command could not launch the cached binary",
+          selection.revision
+        );
+        if (shouldRetryUnavailableBin(bin)) {
+          excludedAttempt = selection;
+          continue;
+        }
+      }
+      logger.error(
+        LogEvent.ONCHAINOS_CLI_ERROR,
+        err2 instanceof Error ? err2 : new Error("onchainos command failed"),
+        {
+          component: "onchainos_cli",
+          source: "onchainos",
+          stage: "exec",
+          communicationClass: "onchainos_cli_or_api_issue",
+          operation: redactArgsForLog(args).slice(0, 3).join(" "),
+          reason: "exec_failed",
+          argCount: String(args.length),
+          exitCode: String(err2?.code ?? ""),
+          signal: String(err2?.signal ?? ""),
+          killed: String(err2?.killed ?? ""),
+          stderrBytes: String(Buffer.byteLength(String(err2?.stderr ?? ""), "utf8")),
+          stdoutBytes: String(Buffer.byteLength(String(err2?.stdout ?? ""), "utf8")),
+          cliErrorName: err2 instanceof Error ? err2.name : "",
+          cliErrorMessageLength: String(String(err2?.message ?? "").length),
+          durationMs: String(Date.now() - t0),
+          timeoutMs: String(options.timeoutMs ?? "")
+        }
+      );
+      throw err2;
+    }
   }
+  throw new Error("OnchainOS command retry exhausted");
 }
-var import_node_fs20, import_node_child_process8, import_node_path24, import_node_util2, execFileAsync2, resolvedBin, versionProbeInFlight, REDACTED_VALUE_FLAGS, ONCHAINOS_VERSION_PROBE_TIMEOUT_MS, ONCHAINOS_BIN_RESOLVE_TIMEOUT_MS, WINDOWS_APPS_ALIAS_MARKER;
+var import_node_fs20, import_node_child_process8, import_node_path24, import_node_util2, execFileAsync2, resolvedBin, resolvedForEnvBin, resolverRevision, versionProbeInFlight, posixDiscoveryFlights, REDACTED_VALUE_FLAGS, COMMAND_UNAVAILABLE_CODES, ONCHAINOS_VERSION_PROBE_TIMEOUT_MS, ONCHAINOS_BIN_RESOLVE_TIMEOUT_MS, WINDOWS_APPS_ALIAS_MARKER;
 var init_bin = __esm({
   "../core/src/xmtp-sdk/onchainos/bin.ts"() {
     "use strict";
@@ -41438,8 +41728,12 @@ var init_bin = __esm({
     init_win_compat();
     execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process8.execFile);
     resolvedBin = null;
+    resolvedForEnvBin = null;
+    resolverRevision = 0;
     versionProbeInFlight = null;
+    posixDiscoveryFlights = /* @__PURE__ */ new Map();
     REDACTED_VALUE_FLAGS = /* @__PURE__ */ new Set(["--message"]);
+    COMMAND_UNAVAILABLE_CODES = /* @__PURE__ */ new Set(["EACCES", "ENOENT", "ENOTDIR"]);
     ONCHAINOS_VERSION_PROBE_TIMEOUT_MS = 5e3;
     ONCHAINOS_BIN_RESOLVE_TIMEOUT_MS = 5e3;
     WINDOWS_APPS_ALIAS_MARKER = "\\microsoft\\windowsapps\\";
@@ -61094,6 +61388,22 @@ function selectAnyJobTarget(messages) {
   }
   return null;
 }
+async function syncConversationsOnLocalMiss(agent) {
+  const conversations = agent.client.conversations;
+  const existing = conversationSyncPromises.get(conversations);
+  if (existing) {
+    return existing;
+  }
+  const pending = conversations.sync();
+  conversationSyncPromises.set(conversations, pending);
+  try {
+    await pending;
+  } finally {
+    if (conversationSyncPromises.get(conversations) === pending) {
+      conversationSyncPromises.delete(conversations);
+    }
+  }
+}
 async function findConversation(agent, target) {
   await agent.client.conversations.syncAll([
     import_node_bindings2.ConsentState.Allowed,
@@ -61115,11 +61425,11 @@ async function findConversation(agent, target) {
   return null;
 }
 async function findGroupConversation(agent, groupId) {
-  await agent.client.conversations.syncAll([
-    import_node_bindings2.ConsentState.Allowed,
-    import_node_bindings2.ConsentState.Unknown
-  ]);
-  const conversation = await agent.client.conversations.getConversationById(groupId);
+  let conversation = await agent.client.conversations.getConversationById(groupId);
+  if (!(conversation instanceof Group)) {
+    await syncConversationsOnLocalMiss(agent);
+    conversation = await agent.client.conversations.getConversationById(groupId);
+  }
   return conversation instanceof Group ? conversation : null;
 }
 function buildDmReplyRaw(command, target, localAgentId) {
@@ -61387,6 +61697,9 @@ async function handleSqliteGroupSendCommand(params) {
       let created2 = false;
       if (xmtpGroupId) {
         conversation2 = await findGroupConversation(agent, xmtpGroupId);
+        if (!conversation2) {
+          throw new Error(`conversation not found for stored xmtpGroupId=${xmtpGroupId} after conversation sync`);
+        }
       }
       if (!conversation2) {
         conversation2 = await createGroupForAddress({
@@ -61840,7 +62153,7 @@ async function handleXmtpSendCommand(params) {
     ownedStore?.close();
   }
 }
-var import_node_crypto12, TASK_MIN_VERSION, sqliteGroupSessionPromises, XMTP_SEND_CHECKPOINT, resolvedAgentByIdCache, resolvedAgentByAddressCache;
+var import_node_crypto12, TASK_MIN_VERSION, sqliteGroupSessionPromises, conversationSyncPromises, XMTP_SEND_CHECKPOINT, resolvedAgentByIdCache, resolvedAgentByAddressCache;
 var init_xmtp_send = __esm({
   "src/xmtp-send.ts"() {
     "use strict";
@@ -61859,6 +62172,7 @@ var init_xmtp_send = __esm({
     init_openclaw_route();
     TASK_MIN_VERSION = 1;
     sqliteGroupSessionPromises = /* @__PURE__ */ new Map();
+    conversationSyncPromises = /* @__PURE__ */ new WeakMap();
     XMTP_SEND_CHECKPOINT = "outbound/xmtp_send";
     resolvedAgentByIdCache = /* @__PURE__ */ new Map();
     resolvedAgentByAddressCache = /* @__PURE__ */ new Map();
@@ -64133,15 +64447,15 @@ var init_ai_runner = __esm({
           output: fullOutputForClassification,
           timedOut
         });
+        const runCompletedSuccessfully = provider === "codex" && !timedOut && exitCode === 0 && closeResult.signal === null && aiSessionId !== null && toolFailures.turnCompleted();
         const syntheticToolFailure = synthesizeCodexProsePermissionFailure({
           provider,
           existingFailures: toolFailures.failures,
           errorType: fullOutputErrorType,
-          output: fullOutputForClassification,
+          output: runCompletedSuccessfully ? stdoutFull : fullOutputForClassification,
           exitCode
         });
         const detectedToolFailures = syntheticToolFailure ? [...toolFailures.failures, syntheticToolFailure] : toolFailures.failures;
-        const runCompletedSuccessfully = provider === "codex" && !timedOut && exitCode === 0 && closeResult.signal === null && aiSessionId !== null && toolFailures.turnCompleted();
         const reportableToolFailures = selectReportableAiToolFailures({
           provider,
           failures: detectedToolFailures,
@@ -66348,7 +66662,7 @@ var init_command_processor = __esm({
     init_user_attention_ipc();
     init_sentry_logger();
     init_xmtp_debug();
-    DEFAULT_COMMAND_EXECUTION_TIMEOUT_MS = 5e4;
+    DEFAULT_COMMAND_EXECUTION_TIMEOUT_MS = 12e4;
     DEFAULT_COMMAND_STALE_TIMEOUT_MS = 12e4;
     DEFAULT_AI_COMMAND_STALE_TIMEOUT_MS = 30 * 6e4;
     DEFAULT_XMTP_SEND_CONCURRENCY = 50;
@@ -68379,12 +68693,12 @@ async function runListenerWithLock(options, paths) {
       });
     }
   });
-  service.setPluginVersion("0.2.10-beta-1a0d85b27f-260828092722");
+  service.setPluginVersion("0.2.10");
   await service.init();
   const pluginVersionStatus = service.pluginVersionStatus;
   if (pluginVersionStatus.unavailable) {
     throw new Error(
-      `@okxweb3/a2a-node v${"0.2.10-beta-1a0d85b27f-260828092722"} is below the required minimum v${pluginVersionStatus.minVersion}`
+      `@okxweb3/a2a-node v${"0.2.10"} is below the required minimum v${pluginVersionStatus.minVersion}`
     );
   }
   const systemConfig = service.getSystemConfig();
@@ -68412,7 +68726,7 @@ async function runListenerWithLock(options, paths) {
       onchainosAgentId: "*",
       reason: "system-config missing sentryDsn",
       pluginId: "@okxweb3/a2a-node",
-      pluginVersion: "0.2.10-beta-1a0d85b27f-260828092722"
+      pluginVersion: "0.2.10"
     });
   }
   logWithTimestamp(
@@ -116739,7 +117053,7 @@ async function getCurrentNodeCliVersion() {
   return await getGlobalNpmPackageVersion(UPDATE_PACKAGES.node) ?? getBundledNodeCliVersion();
 }
 function getBundledNodeCliVersion() {
-  return true ? "0.2.10-beta-1a0d85b27f-260828092722" : null;
+  return true ? "0.2.10" : null;
 }
 function readConfiguredAiProvider() {
   const explicit = process.env.OKX_A2A_AI_PROVIDER || process.env.OKX_AGENT_TASK_AI_CLI;
@@ -116949,7 +117263,7 @@ async function updateHermes(release, options) {
   }
 }
 async function installGatewayPluginForDoctor(target) {
-  const release = isPrereleaseVersion("0.2.10-beta-1a0d85b27f-260828092722") ? "beta" : "latest";
+  const release = isPrereleaseVersion("0.2.10") ? "beta" : "latest";
   const insideTargetGateway = detectGatewayInvocation() === target;
   const options = {
     restart: !insideTargetGateway,
@@ -118002,7 +118316,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.10-beta-1a0d85b27f-260828092722" : "0.0.0"),
+    cliVersion: options.cliVersion ?? (true ? "0.2.10" : "0.0.0"),
     fixMode: options.fix === true,
     nonInteractive: options.nonInteractive === true,
     packageChanged: false,
@@ -119079,7 +119393,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.10-beta-1a0d85b27f-260828092722"}
+  console.log(`okx-a2a ${"0.2.10"}
 
 Usage:
   okx-a2a <command> [options]
@@ -119119,7 +119433,7 @@ Run \`okx-a2a <command> -h\` for command-specific help.
 `);
 }
 function printVersion() {
-  console.log("0.2.10-beta-1a0d85b27f-260828092722");
+  console.log("0.2.10");
 }
 function printDaemonUsage() {
   console.log(`Usage: okx-a2a daemon <start|restart|stop|status|autostart> [options]
@@ -120597,7 +120911,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.10-beta-1a0d85b27f-260828092722",
+      packageVersion: "0.2.10",
       agentSdkVersion: "2.3.0",
       nodeSdkVersion: "6.1.0",
       nodeBindingsVersion: "1.11.0"