@okxweb3/a2a-node 0.2.8-beta-174fcb5625-260819112349 → 0.2.8

package/dist/cli.js

@@ -1536,6 +1536,16 @@ var init_session_store = __esm({
         }
         return null;
       }
+      setAiRuntimeSurface(surface) {
+        if (surface !== "desktop" && surface !== "cli" && surface !== "unknown") {
+          throw new Error(`Unsupported AI runtime surface: ${surface}`);
+        }
+        this.setSetting("ai_runtime_surface", surface);
+      }
+      getAiRuntimeSurface() {
+        const value = this.getSetting("ai_runtime_surface");
+        return value === "desktop" || value === "cli" || value === "unknown" ? value : null;
+      }
       setAiProviderCommand(provider, command) {
         assertAiProvider(provider);
         assertNonEmpty(command, "command");
@@ -2691,7 +2701,7 @@ __export(autostart_exports, {
   uninstallSystemdAutostart: () => uninstallSystemdAutostart
 });
 function isSystemdManagerUnavailableMessage(message) {
-  return /spawn systemctl ENOENT|system has not been booted with systemd|failed to connect to bus/i.test(message);
+  return /spawn systemctl ENOENT|system has not been booted with systemd|failed to connect to bus|systemctl shim:\s*unsupported unit\b/i.test(message);
 }
 function isAutostartManagerUnavailableError(error) {
   return error instanceof AutostartManagerUnavailableError || typeof error === "object" && error !== null && "code" in error && error.code === "AUTOSTART_MANAGER_UNAVAILABLE";
@@ -2821,35 +2831,81 @@ async function runSystemctl(args, options = {}) {
     throw new Error(message);
   }
 }
-async function probeSystemdManager() {
+async function systemdRuntimePresence() {
+  if (process.platform !== "linux") {
+    return "unknown";
+  }
+  if ((0, import_node_fs6.existsSync)("/run/systemd/system")) {
+    return "present";
+  }
+  const runtimeDir = process.env.XDG_RUNTIME_DIR?.trim();
+  if (runtimeDir && (0, import_node_fs6.existsSync)((0, import_node_path9.join)(runtimeDir, "systemd"))) {
+    return "present";
+  }
+  try {
+    const initName = (await (0, import_promises3.readFile)("/proc/1/comm", "utf8")).trim();
+    return initName === "systemd" ? "present" : "absent";
+  } catch {
+    return "unknown";
+  }
+}
+function isDefinitiveSystemdUnavailableMessage(message) {
+  return /spawn systemctl ENOENT|system has not been booted with systemd|systemctl shim:\s*unsupported unit\b/i.test(message);
+}
+async function classifyFailedSystemdProbe(message, options = {}) {
+  if (isDefinitiveSystemdUnavailableMessage(message)) {
+    return "unavailable";
+  }
+  if (options.previouslyAvailable) {
+    return "unknown";
+  }
+  const runtime = await systemdRuntimePresence();
+  if (runtime === "absent") {
+    return "unavailable";
+  }
+  if (runtime === "present") {
+    return "unknown";
+  }
+  return isSystemdManagerUnavailableMessage(message) ? "unavailable" : "unknown";
+}
+async function probeSystemdManager(options = {}) {
   const manager = await runSystemctl(["show", "--property=Version", "--value"], { tolerateFailure: true });
   if (!manager.ok) {
     const message = (manager.stderr || manager.stdout).trim();
     return {
-      managed: false,
+      state: await classifyFailedSystemdProbe(message, options),
       message: message || "systemd user manager is unavailable"
     };
   }
-  return { managed: true };
+  return { state: "available" };
 }
-async function probeSystemdUnitOwnership() {
-  const manager = await probeSystemdManager();
-  if (!manager.managed) {
-    return manager;
+async function probeSystemdUnitOwnership(options = {}) {
+  const manager = await probeSystemdManager({ previouslyAvailable: options.managerPreviouslyAvailable });
+  if (manager.state !== "available") {
+    return { state: manager.state, ...manager.message ? { message: manager.message } : {} };
   }
   const unit = await runSystemctl(
     ["show", SERVICE_NAME, "--property=LoadState", "--value"],
     { tolerateFailure: true }
   );
   const loadState = unit.stdout.trim().toLowerCase();
-  if (!unit.ok || loadState !== "loaded") {
-    const detail = (unit.stderr || unit.stdout).trim();
+  if (unit.ok) {
+    if (loadState === "loaded") {
+      return { state: "managed" };
+    }
     return {
-      managed: false,
-      message: detail || `systemd reports ${SERVICE_NAME} LoadState=${loadState || "unknown"}`
+      state: "unmanaged",
+      message: `systemd reports ${SERVICE_NAME} LoadState=${loadState || "unknown"}`
     };
   }
-  return { managed: true };
+  const detail = (unit.stderr || unit.stdout).trim();
+  if (loadState || isSystemdMissingServiceMessage(detail)) {
+    return { state: "unmanaged", ...detail ? { message: detail } : {} };
+  }
+  return {
+    state: await classifyFailedSystemdProbe(detail, { previouslyAvailable: true }),
+    message: detail || `could not verify whether systemd manages ${SERVICE_NAME}`
+  };
 }
 async function runLaunchctl(args, options = {}) {
   try {
@@ -2885,20 +2941,16 @@ async function installSystemdAutostart() {
   const paths = resolveSystemdAutostartPaths();
   const previousContent = (0, import_node_fs6.existsSync)(paths.servicePath) ? await (0, import_promises3.readFile)(paths.servicePath, "utf8") : null;
   const manager = await probeSystemdManager();
-  if (!manager.managed) {
+  if (manager.state === "unavailable") {
     await (0, import_promises3.rm)(paths.servicePath, { force: true });
     throw new AutostartManagerUnavailableError(
       manager.message || "systemd user manager is unavailable"
     );
   }
-  if (previousContent !== null) {
-    const ownership = await probeSystemdUnitOwnership();
-    if (!ownership.managed) {
-      await (0, import_promises3.rm)(paths.servicePath, { force: true });
-      throw new AutostartManagerUnavailableError(
-        ownership.message || `systemd does not manage ${SERVICE_NAME}`
-      );
-    }
+  if (manager.state === "unknown") {
+    throw new Error(
+      `could not verify systemd user manager availability${manager.message ? `: ${manager.message}` : ""}`
+    );
   }
   await (0, import_promises3.mkdir)(paths.serviceDir, { recursive: true });
   await (0, import_promises3.writeFile)(paths.servicePath, buildSystemdUserService(), "utf8");
@@ -2906,11 +2958,21 @@ async function installSystemdAutostart() {
     await runSystemctl(["daemon-reload"]);
     await runSystemctl(["enable", "--now", SERVICE_NAME]);
   } catch (error) {
-    if (isAutostartManagerUnavailableError(error) || previousContent === null) {
+    const managerAfterFailure = await probeSystemdManager({ previouslyAvailable: true });
+    if (managerAfterFailure.state === "unavailable") {
+      await (0, import_promises3.rm)(paths.servicePath, { force: true });
+      throw new AutostartManagerUnavailableError(
+        managerAfterFailure.message || (error instanceof Error ? error.message : String(error))
+      );
+    }
+    if (previousContent === null) {
       await (0, import_promises3.rm)(paths.servicePath, { force: true });
     } else {
       await (0, import_promises3.writeFile)(paths.servicePath, previousContent, "utf8");
     }
+    if (isAutostartManagerUnavailableError(error)) {
+      throw new Error(error instanceof Error ? error.message : String(error));
+    }
     throw error;
   }
   return { platform: "linux-systemd", path: paths.servicePath };
@@ -2941,7 +3003,7 @@ async function stopSystemdAutostart() {
   return {
     platform: "linux-systemd",
     path: paths.servicePath,
-    stopped: !missing,
+    stopped: result.ok && !missing,
     ...message ? { message } : {}
   };
 }
@@ -2956,7 +3018,7 @@ async function restartSystemdAutostart() {
     };
   }
   const ownership = await probeSystemdUnitOwnership();
-  if (!ownership.managed) {
+  if (ownership.state === "unavailable") {
     await (0, import_promises3.rm)(paths.servicePath, { force: true });
     return {
       platform: "linux-systemd",
@@ -2966,11 +3028,27 @@ async function restartSystemdAutostart() {
       ...ownership.message ? { message: ownership.message } : {}
     };
   }
+  if (ownership.state === "unknown") {
+    return {
+      platform: "linux-systemd",
+      path: paths.servicePath,
+      restarted: false,
+      message: ownership.message || `could not verify whether systemd manages ${SERVICE_NAME}`
+    };
+  }
+  if (ownership.state === "unmanaged") {
+    const installed = await installSystemdAutostart();
+    return {
+      ...installed,
+      restarted: true,
+      ...ownership.message ? { message: `systemd service was not loaded; reinstalled autostart. ${ownership.message}` } : {}
+    };
+  }
   const result = await runSystemctl(["restart", SERVICE_NAME], { tolerateFailure: true });
   const message = (result.stderr || result.stdout).trim();
   if (!result.ok) {
-    const ownershipAfterFailure = await probeSystemdUnitOwnership();
-    if (!ownershipAfterFailure.managed) {
+    const ownershipAfterFailure = await probeSystemdUnitOwnership({ managerPreviouslyAvailable: true });
+    if (ownershipAfterFailure.state === "unavailable") {
       await (0, import_promises3.rm)(paths.servicePath, { force: true });
       return {
         platform: "linux-systemd",
@@ -2980,6 +3058,14 @@ async function restartSystemdAutostart() {
         message: ownershipAfterFailure.message || message
       };
     }
+    if (ownershipAfterFailure.state === "unmanaged") {
+      const installed = await installSystemdAutostart();
+      return {
+        ...installed,
+        restarted: true,
+        message: ownershipAfterFailure.message || message
+      };
+    }
   }
   return {
     platform: "linux-systemd",
@@ -19874,6 +19960,7 @@ var init_events = __esm({
       PROVIDER_READINESS_CHECKED: "Provider readiness checked",
       PROVIDER_SWITCHED: "Provider switched",
       JOB_PROVIDER_BOUND: "Job provider bound",
+      ONCHAINOS_VERSION_OBSERVED: "OnchainOS version observed",
       // Hermes user-channel delivery only. The node and openclaw user-channel hops
       // keep emitting USER_DISPATCHED / PROMPT_USER_CHECKPOINT — one name per
       // transport is the whole point of splitting the send events.
@@ -20410,7 +20497,84 @@ var init_error_diagnostics = __esm({
   }
 });
 
+// ../core/src/sentry-logger/runtime-metadata.ts
+function normalizeAiRuntimeProvider(provider) {
+  const normalized = provider?.trim().toLowerCase();
+  if (normalized === "codex") {
+    return "codex";
+  }
+  if (normalized === "claude" || normalized === "claude-code") {
+    return "claude-code";
+  }
+  if (normalized === "openclaw") {
+    return "openclaw";
+  }
+  if (normalized === "hermes") {
+    return "hermes";
+  }
+  return "unknown";
+}
+function detectAiRuntimeSurface(provider, env = process.env) {
+  const override = env.OKX_A2A_RUNTIME_SURFACE?.trim().toLowerCase();
+  if (override === "desktop" || override === "cli" || override === "unknown") {
+    return override;
+  }
+  const normalizedProvider = normalizeAiRuntimeProvider(provider);
+  if (normalizedProvider === "codex") {
+    return env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE === "Codex Desktop" ? "desktop" : "cli";
+  }
+  if (normalizedProvider === "claude-code") {
+    return env.CLAUDE_CODE_ENTRYPOINT?.trim().toLowerCase() === "remote_cowork" ? "desktop" : "cli";
+  }
+  return "unknown";
+}
+function parseOnchainosVersionOutput(output5) {
+  const normalized = output5.trim().replace(/\s+/g, " ");
+  if (!normalized) {
+    return UNKNOWN_RUNTIME_METADATA;
+  }
+  const match = ` ${normalized} `.match(SEMVER_PATTERN);
+  return match?.[1]?.slice(0, 128) ?? UNKNOWN_RUNTIME_METADATA;
+}
+function runtimeMetadataFields(input = {}) {
+  const observedAt = Number(input.onchainosVersionObservedAtMs);
+  return {
+    aiProvider: normalizeAiRuntimeProvider(input.aiProvider),
+    runtimeSurface: input.runtimeSurface === "desktop" || input.runtimeSurface === "cli" ? input.runtimeSurface : UNKNOWN_RUNTIME_METADATA,
+    onchainosVersion: typeof input.onchainosVersion === "string" && input.onchainosVersion.trim() ? input.onchainosVersion.trim().slice(0, 128) : UNKNOWN_RUNTIME_METADATA,
+    onchainosVersionObservedAtMs: Number.isFinite(observedAt) && observedAt > 0 ? String(Math.trunc(observedAt)) : "0",
+    onchainosVersionProbeStatus: typeof input.onchainosVersionProbeStatus === "string" && input.onchainosVersionProbeStatus.trim() ? input.onchainosVersionProbeStatus.trim().toLowerCase().slice(0, 32) : UNKNOWN_RUNTIME_METADATA
+  };
+}
+var UNKNOWN_RUNTIME_METADATA, SEMVER_PATTERN;
+var init_runtime_metadata = __esm({
+  "../core/src/sentry-logger/runtime-metadata.ts"() {
+    "use strict";
+    UNKNOWN_RUNTIME_METADATA = "unknown";
+    SEMVER_PATTERN = /(?:^|[^0-9])v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)(?:$|[^0-9A-Za-z.-])/;
+  }
+});
+
 // ../core/src/sentry-logger/index.ts
+function setRuntimeMetadata(metadata) {
+  const next = runtimeMetadataFields({
+    ...RUNTIME_FIELDS,
+    ...metadata
+  });
+  RUNTIME_FIELDS = next;
+  try {
+    Sentry.setTags({
+      aiProvider: next.aiProvider,
+      runtimeSurface: next.runtimeSurface,
+      onchainosVersion: next.onchainosVersion,
+      onchainosVersionProbeStatus: next.onchainosVersionProbeStatus
+    });
+  } catch {
+  }
+}
+function getRuntimeMetadata() {
+  return { ...RUNTIME_FIELDS };
+}
 function applyFatalEventDefaults(event) {
   try {
     const classified = event?.extra?.eventName ?? event?.tags?.eventName;
@@ -20420,6 +20584,7 @@ function applyFatalEventDefaults(event) {
     const target = event;
     target.extra = {
       ...RELEASE_FIELDS,
+      ...RUNTIME_FIELDS,
       ...target.extra ?? {},
       eventName: LogEvent.FATAL_UNCAUGHT,
       eventFamily: "diagnostics",
@@ -20445,7 +20610,7 @@ function agentExtras(identity) {
     role: identity.role != null && identity.role !== "" ? String(identity.role) : UNKNOWN_FIELD
   };
 }
-var Sentry, import_node_crypto4, FLOW_ID, SENTRY_EXTRA_BLOCKLIST, SENTRY_EXTRA_BLOCKED_KEY_PARTS, SENTRY_FULL_STRING_EXTRA_KEYS, SENTRY_TAG_KEYS, SENTRY_FINGERPRINT_KEYS, SENTRY_INFO_ALLOWLIST, MAX_EXTRA_STRING_LENGTH, MAX_TAG_VALUE_LENGTH, RELEASE_FIELDS, SentryLogger, logger, initLogger, shutdown, UNKNOWN_FIELD;
+var Sentry, import_node_crypto4, FLOW_ID, SENTRY_EXTRA_BLOCKLIST, SENTRY_EXTRA_BLOCKED_KEY_PARTS, SENTRY_FULL_STRING_EXTRA_KEYS, SENTRY_TAG_KEYS, SENTRY_FINGERPRINT_KEYS, SENTRY_INFO_ALLOWLIST, MAX_EXTRA_STRING_LENGTH, MAX_TAG_VALUE_LENGTH, RELEASE_FIELDS, RUNTIME_FIELDS, SentryLogger, logger, initLogger, shutdown, UNKNOWN_FIELD;
 var init_sentry_logger = __esm({
   "../core/src/sentry-logger/index.ts"() {
     "use strict";
@@ -20456,6 +20621,7 @@ var init_sentry_logger = __esm({
     init_log_fields();
     init_xmtp_test_metrics();
     init_error_diagnostics();
+    init_runtime_metadata();
     init_events();
     init_log_fields();
     FLOW_ID = (0, import_node_crypto4.randomUUID)();
@@ -20542,6 +20708,7 @@ var init_sentry_logger = __esm({
     SENTRY_TAG_KEYS = /* @__PURE__ */ new Set([
       "agentId",
       "agentPlatform",
+      "aiProvider",
       "cacheName",
       "causeCode",
       "causeType",
@@ -20564,6 +20731,8 @@ var init_sentry_logger = __esm({
       "kind",
       "method",
       "onchainosAgentId",
+      "onchainosVersion",
+      "onchainosVersionProbeStatus",
       "operation",
       "originPlatform",
       "outcome",
@@ -20580,6 +20749,7 @@ var init_sentry_logger = __esm({
       "role",
       "runId",
       "runtimeContainer",
+      "runtimeSurface",
       "senderAgentId",
       "source",
       "stage",
@@ -20650,6 +20820,7 @@ var init_sentry_logger = __esm({
       LogEvent.PROVIDER_READINESS_CHECKED,
       LogEvent.PROVIDER_SWITCHED,
       LogEvent.JOB_PROVIDER_BOUND,
+      LogEvent.ONCHAINOS_VERSION_OBSERVED,
       LogEvent.USER_CHANNEL_MESSAGE_DELIVERED,
       LogEvent.SYSTEM_NOTIFICATION_RECEIVED,
       LogEvent.SYSTEM_NOTIFICATION_ROUTED,
@@ -20705,6 +20876,7 @@ var init_sentry_logger = __esm({
     MAX_EXTRA_STRING_LENGTH = 256;
     MAX_TAG_VALUE_LENGTH = 128;
     RELEASE_FIELDS = {};
+    RUNTIME_FIELDS = runtimeMetadataFields();
     SentryLogger = class _SentryLogger {
       static instance;
       initialized = false;
@@ -20724,6 +20896,9 @@ var init_sentry_logger = __esm({
         }
         try {
           RELEASE_FIELDS = releaseFields(config.release);
+          if (config.runtimeMetadata) {
+            setRuntimeMetadata(config.runtimeMetadata);
+          }
           Sentry.init({
             dsn: config.dsn,
             release: config.release,
@@ -20743,6 +20918,14 @@ var init_sentry_logger = __esm({
           if (config.runtimeContainer) {
             tags.runtimeContainer = config.runtimeContainer;
           }
+          for (const key of [
+            "aiProvider",
+            "runtimeSurface",
+            "onchainosVersion",
+            "onchainosVersionProbeStatus"
+          ]) {
+            tags[key] = RUNTIME_FIELDS[key] ?? "unknown";
+          }
           Sentry.setTags(tags);
         } catch {
           return;
@@ -20755,6 +20938,7 @@ var init_sentry_logger = __esm({
           enrichCorrelationFields({
             flowId: FLOW_ID,
             ...RELEASE_FIELDS,
+            ...RUNTIME_FIELDS,
             ...extra ?? {}
           })
         );
@@ -20789,6 +20973,7 @@ var init_sentry_logger = __esm({
           enrichCorrelationFields({
             flowId: FLOW_ID,
             ...RELEASE_FIELDS,
+            ...RUNTIME_FIELDS,
             ...extra ?? {}
           })
         );
@@ -26747,7 +26932,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     client: {
       id: "gateway-client",
       displayName: "okx-a2a-node",
-      version: "0.2.8-beta-174fcb5625-260819112349",
+      version: "0.2.8",
       platform: "node",
       mode: "backend",
       instanceId
@@ -26758,7 +26943,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     commands: [],
     permissions: {},
     locale: Intl.DateTimeFormat().resolvedOptions().locale || "en-US",
-    userAgent: `okx-a2a-node/${"0.2.8-beta-174fcb5625-260819112349"}`,
+    userAgent: `okx-a2a-node/${"0.2.8"}`,
     auth: {
       ...config.token ? { token: config.token } : {},
       ...config.password ? { password: config.password } : {}
@@ -28229,6 +28414,48 @@ var init_outbound_behavior = __esm({
   }
 });
 
+// src/runtime-metadata-store.ts
+function defaultWarning(message) {
+  console.warn(message);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function warnBestEffort(warn, message) {
+  try {
+    warn(message);
+  } catch {
+  }
+}
+function persistAiRuntimeSurfaceBestEffort(store, surface, warn = defaultWarning) {
+  try {
+    store.setAiRuntimeSurface(surface);
+    return true;
+  } catch (error) {
+    warnBestEffort(
+      warn,
+      `[runtime] failed to persist diagnostic runtime surface: ${errorMessage(error)}`
+    );
+    return false;
+  }
+}
+function readAiRuntimeSurfaceBestEffort(store, fallback, warn = defaultWarning) {
+  try {
+    return store.getAiRuntimeSurface() ?? fallback;
+  } catch (error) {
+    warnBestEffort(
+      warn,
+      `[runtime] failed to read diagnostic runtime surface: ${errorMessage(error)}`
+    );
+    return fallback;
+  }
+}
+var init_runtime_metadata_store = __esm({
+  "src/runtime-metadata-store.ts"() {
+    "use strict";
+  }
+});
+
 // src/runtime-switch.ts
 async function performRuntimeSwitch(store, options = {}) {
   const result = await switchProviderWithReadinessGate({
@@ -28242,11 +28469,25 @@ async function performRuntimeSwitch(store, options = {}) {
 }
 async function switchProviderWithReadinessGate(options) {
   const gated = await switchProviderWithReadinessGateCore(options);
-  emitRuntimeSwitchCheckpoints(gated);
+  if (gated.result.ok) {
+    const provider = normalizeAiRuntimeProvider(gated.result.provider);
+    persistAiRuntimeSurfaceBestEffort(
+      options.store,
+      detectAiRuntimeSurface(provider, options.env)
+    );
+  }
+  emitRuntimeSwitchCheckpoints(gated, options.env);
   return gated.result;
 }
-function emitRuntimeSwitchCheckpoints(gated) {
+function emitRuntimeSwitchCheckpoints(gated, env = process.env) {
   const { result, runtime, readiness } = gated;
+  const runtimeProvider = normalizeAiRuntimeProvider(
+    result.ok ? result.provider : runtime
+  );
+  setRuntimeMetadata({
+    aiProvider: runtimeProvider,
+    runtimeSurface: detectAiRuntimeSurface(runtimeProvider, env)
+  });
   logger.info(LogEvent.RUNTIME_DETECTED, {
     component: RUNTIME_SWITCH_COMPONENT,
     provider: runtime,
@@ -28318,8 +28559,10 @@ var init_runtime_switch = __esm({
     init_ai_provider();
     init_outbound_behavior();
     init_openclaw_route();
+    init_runtime_metadata_store();
     init_sentry_logger();
     init_log_fields();
+    init_runtime_metadata();
     RUNTIME_SWITCH_COMPONENT = "node_runtime_switch";
   }
 });
@@ -28667,7 +28910,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.8-beta-174fcb5625-260819112349",
+      release: "0.2.8",
       environment,
       runtimeContainer: normalizeRuntimeContainer(process.env.OKX_A2A_RUNTIME_CONTAINER)
     };
@@ -39837,7 +40080,7 @@ async function exportDiagnosticLogs(options) {
     node: process.version,
     platform: process.platform,
     arch: process.arch,
-    packageVersion: true ? "0.2.8-beta-174fcb5625-260819112349" : "unknown",
+    packageVersion: true ? "0.2.8" : "unknown",
     sensitiveContentIncluded: options.includeSensitiveContent,
     listenerAndLlmContentIncluded: true,
     credentialsAlwaysRedacted: true,
@@ -40761,7 +41004,87 @@ var init_capabilities_cli = __esm({
 });
 
 // ../core/src/xmtp-sdk/onchainos/bin.ts
-async function resolve9() {
+async function refreshOnchainosVersionMetadata(options = {}) {
+  const now = options.now ?? Date.now;
+  const current = getRuntimeMetadata();
+  const previousVersion = current.onchainosVersion ?? UNKNOWN_RUNTIME_METADATA;
+  const previousObservedAtMs = Number(current.onchainosVersionObservedAtMs ?? 0);
+  if (versionProbeInFlight) {
+    return versionProbeInFlight;
+  }
+  versionProbeInFlight = (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 version3 = parseOnchainosVersionOutput(output5);
+      if (version3 === UNKNOWN_RUNTIME_METADATA) {
+        throw new Error("OnchainOS version output did not contain a semantic version");
+      }
+      const changed = previousVersion !== UNKNOWN_RUNTIME_METADATA && previousVersion !== version3;
+      setRuntimeMetadata({
+        onchainosVersion: version3,
+        onchainosVersionObservedAtMs: observedAtMs,
+        onchainosVersionProbeStatus: "ok"
+      });
+      if (previousVersion !== version3) {
+        logger.info(LogEvent.ONCHAINOS_VERSION_OBSERVED, {
+          component: "onchainos_cli",
+          source: "onchainos",
+          checkpoint: changed ? "version_changed" : "version_detected",
+          outcome: "success",
+          previousOnchainosVersion: previousVersion,
+          versionChanged: String(changed),
+          onchainosVersionObservedAtMs: String(observedAtMs)
+        });
+      }
+      return {
+        version: version3,
+        observedAtMs,
+        probeStatus: "ok",
+        changed
+      };
+    } catch {
+      const hasLastKnownVersion = previousVersion !== UNKNOWN_RUNTIME_METADATA;
+      setRuntimeMetadata({
+        onchainosVersion: previousVersion,
+        onchainosVersionObservedAtMs: previousObservedAtMs,
+        onchainosVersionProbeStatus: "failed"
+      });
+      if (!hasLastKnownVersion) {
+        logger.info(LogEvent.ONCHAINOS_VERSION_OBSERVED, {
+          component: "onchainos_cli",
+          source: "onchainos",
+          checkpoint: "version_probe_failed",
+          outcome: "failed",
+          reason: "version_unavailable",
+          onchainosVersionObservedAtMs: "0"
+        });
+      }
+      return {
+        version: previousVersion,
+        observedAtMs: previousObservedAtMs,
+        probeStatus: "failed",
+        changed: false
+      };
+    } finally {
+      versionProbeInFlight = null;
+    }
+  })();
+  return versionProbeInFlight;
+}
+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
+  });
+  return [result.stdout, result.stderr].filter(Boolean).join("\n");
+}
+async function resolve9(timeoutMs) {
   if (resolvedBin) {
     return resolvedBin;
   }
@@ -40781,7 +41104,8 @@ async function resolve9() {
     try {
       const shell = process.env.SHELL || "/bin/bash";
       const { stdout } = await execFileAsync2(shell, ["-lc", "command -v onchainos"], {
-        windowsHide: true
+        windowsHide: true,
+        timeout: timeoutMs
       });
       const bin = extractExecutablePath(stdout);
       if (bin) {
@@ -41006,7 +41330,7 @@ async function exec(args, options = {}) {
     throw err2;
   }
 }
-var import_node_fs20, import_node_child_process8, import_node_path23, import_node_util2, execFileAsync2, resolvedBin, REDACTED_VALUE_FLAGS, WINDOWS_APPS_ALIAS_MARKER;
+var import_node_fs20, import_node_child_process8, import_node_path23, import_node_util2, execFileAsync2, resolvedBin, versionProbeInFlight, REDACTED_VALUE_FLAGS, 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";
@@ -41016,10 +41340,14 @@ var init_bin = __esm({
     import_node_path23 = require("node:path");
     import_node_util2 = require("node:util");
     init_sentry_logger();
+    init_runtime_metadata();
     init_win_compat();
     execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process8.execFile);
     resolvedBin = null;
+    versionProbeInFlight = null;
     REDACTED_VALUE_FLAGS = /* @__PURE__ */ new Set(["--message"]);
+    ONCHAINOS_VERSION_PROBE_TIMEOUT_MS = 5e3;
+    ONCHAINOS_BIN_RESOLVE_TIMEOUT_MS = 5e3;
     WINDOWS_APPS_ALIAS_MARKER = "\\microsoft\\windowsapps\\";
   }
 });
@@ -61766,6 +62094,8 @@ function aiRunSentryExtra(input) {
     // Every event this builder feeds describes one AI CLI child process.
     transport: "cli",
     eventFamily: "ai_run",
+    // A daemon-spawned AI process is not a user-selected Desktop/CLI surface.
+    runtimeSurface: "unknown",
     source: input.source,
     sessionKey: input.sessionKey,
     jobId: input.jobId ?? "",
@@ -63502,6 +63832,7 @@ var init_ai_runner = __esm({
           env: buildAiProviderEnv(command, {
             ...process.env,
             OKX_A2A_IS_CLI: "1",
+            OKX_A2A_RUNTIME_SURFACE: "unknown",
             OKX_AGENT_TASK_AI_PROVIDER: provider,
             OKX_A2A_CURRENT_SESSION_KEY: request.sessionKey,
             OKX_A2A_CURRENT_MESSAGE_ID: request.messageId,
@@ -67474,8 +67805,9 @@ __export(listener_exports, {
 async function runHeartbeatRefreshCycle(options) {
   const heartbeat = await timeSettled(options.heartbeat);
   const refreshAllowed = heartbeat.value === "performed" || heartbeat.value === "refresh_safe";
+  const versionRefresh = options.versionRefresh && refreshAllowed ? await timeSettled(options.versionRefresh) : void 0;
   const refresh = options.refresh && refreshAllowed ? await timeSettled(options.refresh) : void 0;
-  return { heartbeat, refresh };
+  return { heartbeat, versionRefresh, refresh };
 }
 function resolveOfflineReplayIntervalSec(systemConfig) {
   const interval = systemConfig.offlineReplayInterval;
@@ -67747,15 +68079,25 @@ async function runListenerWithLock(options, paths) {
       });
     }
   });
-  service.setPluginVersion("0.2.8-beta-174fcb5625-260819112349");
+  service.setPluginVersion("0.2.8");
   await service.init();
   const pluginVersionStatus = service.pluginVersionStatus;
   if (pluginVersionStatus.unavailable) {
     throw new Error(
-      `@okxweb3/a2a-node v${"0.2.8-beta-174fcb5625-260819112349"} is below the required minimum v${pluginVersionStatus.minVersion}`
+      `@okxweb3/a2a-node v${"0.2.8"} is below the required minimum v${pluginVersionStatus.minVersion}`
     );
   }
   const systemConfig = service.getSystemConfig();
+  const configuredProvider = resolveConfiguredAiProvider({ store: sessionStore }) ?? detectGatewayInvocation();
+  const aiProvider = normalizeAiRuntimeProvider(configuredProvider);
+  setRuntimeMetadata({
+    aiProvider,
+    runtimeSurface: readAiRuntimeSurfaceBestEffort(
+      sessionStore,
+      detectAiRuntimeSurface(aiProvider),
+      (message) => logWithTimestamp(message)
+    )
+  });
   if (systemConfig.sentryDsn) {
     initLogger({
       dsn: systemConfig.sentryDsn,
@@ -67770,7 +68112,7 @@ async function runListenerWithLock(options, paths) {
       onchainosAgentId: "*",
       reason: "system-config missing sentryDsn",
       pluginId: "@okxweb3/a2a-node",
-      pluginVersion: "0.2.8-beta-174fcb5625-260819112349"
+      pluginVersion: "0.2.8"
     });
   }
   logWithTimestamp(
@@ -68028,6 +68370,7 @@ async function runListenerWithLock(options, paths) {
     timer = setInterval(() => {
       void runHeartbeatRefreshCycle({
         heartbeat: heartbeatTick,
+        versionRefresh: refreshOnchainosVersionMetadata,
         refresh: syncTick
       });
     }, intervalSec * 1e3);
@@ -68132,7 +68475,8 @@ async function runListenerWithLock(options, paths) {
     });
   }, AUTH_RECOVERY_PROBE_INTERVAL_MS);
   void runHeartbeatRefreshCycle({
-    heartbeat: heartbeatTick
+    heartbeat: heartbeatTick,
+    versionRefresh: refreshOnchainosVersionMetadata
   });
   const commandProcessor = startCommandProcessor({
     service,
@@ -68211,6 +68555,7 @@ var init_listener = __esm({
     init_system_config();
     init_offline_replay_capability();
     init_signer();
+    init_bin();
     init_xmtp_sdk();
     init_file_store();
     init_session_store();
@@ -68225,7 +68570,9 @@ var init_listener = __esm({
     init_daemon_lock();
     init_ai_provider();
     init_openclaw_gateway();
+    init_runtime_metadata_store();
     init_sentry_logger();
+    init_runtime_metadata();
     init_sentry_config();
     DEFAULT_OFFLINE_REPLAY_INTERVAL_SEC = 300;
     DEFAULT_XMTP_CLIENT_RECYCLE_INTERVAL_SEC = 6 * 60 * 60;
@@ -116172,7 +116519,7 @@ async function getCurrentNodeCliVersion() {
   return await getGlobalNpmPackageVersion(UPDATE_PACKAGES.node) ?? getBundledNodeCliVersion();
 }
 function getBundledNodeCliVersion() {
-  return true ? "0.2.8-beta-174fcb5625-260819112349" : null;
+  return true ? "0.2.8" : null;
 }
 function readConfiguredAiProvider() {
   const explicit = process.env.OKX_A2A_AI_PROVIDER || process.env.OKX_AGENT_TASK_AI_CLI;
@@ -116382,7 +116729,7 @@ async function updateHermes(release, options) {
   }
 }
 async function installGatewayPluginForDoctor(target) {
-  const release = isPrereleaseVersion("0.2.8-beta-174fcb5625-260819112349") ? "beta" : "latest";
+  const release = isPrereleaseVersion("0.2.8") ? "beta" : "latest";
   const insideTargetGateway = detectGatewayInvocation() === target;
   const options = {
     restart: !insideTargetGateway,
@@ -117225,6 +117572,11 @@ function initDoctorSentry() {
   }
   try {
     const dsn = process.env.OKX_A2A_SENTRY_DSN?.trim() || process.env.SENTRY_DSN?.trim() || FALLBACK_SENTRY_DSN;
+    const aiProvider = normalizeAiRuntimeProvider(detectCurrentAiProvider());
+    setRuntimeMetadata({
+      aiProvider,
+      runtimeSurface: detectAiRuntimeSurface(aiProvider)
+    });
     initLogger({
       dsn,
       ...SENTRY_CONFIG,
@@ -117308,6 +117660,8 @@ var init_doctor_sentry = __esm({
     "use strict";
     init_sentry_config();
     init_sentry_logger();
+    init_runtime_metadata();
+    init_ai_provider();
     sentryReady = false;
   }
 });
@@ -117428,7 +117782,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.8-beta-174fcb5625-260819112349" : "0.0.0"),
+    cliVersion: options.cliVersion ?? (true ? "0.2.8" : "0.0.0"),
     fixMode: options.fix === true,
     nonInteractive: options.nonInteractive === true,
     packageChanged: false,
@@ -118444,6 +118798,7 @@ init_command_store();
 init_file_store();
 init_ai_provider();
 init_runtime_switch();
+init_runtime_metadata_store();
 init_job_provider();
 init_session_store();
 init_paths();
@@ -118452,9 +118807,10 @@ init_log_tail();
 init_win_spawn();
 init_sentry_logger();
 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.8-beta-174fcb5625-260819112349"}
+  console.log(`okx-a2a ${"0.2.8"}
 
 Usage:
   okx-a2a <command> [options]
@@ -118494,7 +118850,7 @@ Run \`okx-a2a <command> -h\` for command-specific help.
 `);
 }
 function printVersion() {
-  console.log("0.2.8-beta-174fcb5625-260819112349");
+  console.log("0.2.8");
 }
 function printDaemonUsage() {
   console.log(`Usage: okx-a2a daemon <start|restart|stop|status|autostart> [options]
@@ -119327,6 +119683,10 @@ async function configureDefaultAiProviderForLifecycle(args, options = {}) {
       promptIfMissing: options.promptIfMissing ?? true,
       allowUnavailableProvider: options.allowUnavailableProvider
     });
+    persistAiRuntimeSurfaceBestEffort(
+      store,
+      detectAiRuntimeSurface(provider.provider)
+    );
     console.log(provider.message);
   } finally {
     store.close();
@@ -119546,6 +119906,10 @@ async function handleAiProvider(args) {
         requestedProvider: rawProvider,
         stderr: process.stderr
       });
+      persistAiRuntimeSurfaceBestEffort(
+        store,
+        detectAiRuntimeSurface(choice.provider)
+      );
       if (json) {
         console.log(JSON.stringify({ ok: true, provider: choice.provider, source: choice.source }));
       } else {
@@ -119820,7 +120184,7 @@ function assertSupportedNodeVersion() {
 var cliSentryInitAttempted = false;
 var cliSentryInitialized = false;
 var cliSentryFlushTimedOut = false;
-function initDirectCliSentry() {
+async function initDirectCliSentry() {
   if (cliSentryInitAttempted) {
     return;
   }
@@ -119834,6 +120198,11 @@ function initDirectCliSentry() {
     if (typeof config.sentryDsn !== "string" || !config.sentryDsn) {
       return;
     }
+    const aiProvider = normalizeAiRuntimeProvider(detectCurrentAiProvider());
+    setRuntimeMetadata({
+      aiProvider,
+      runtimeSurface: detectAiRuntimeSurface(aiProvider)
+    });
     initLogger({
       dsn: config.sentryDsn,
       ...SENTRY_CONFIG,
@@ -119962,7 +120331,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.8-beta-174fcb5625-260819112349",
+      packageVersion: "0.2.8",
       agentSdkVersion: "2.3.0",
       nodeSdkVersion: "6.1.0",
       nodeBindingsVersion: "1.11.0"
@@ -119970,53 +120339,53 @@ async function main() {
     return;
   }
   if (command === "xmtp-send") {
-    initDirectCliSentry();
+    await initDirectCliSentry();
     await queueXmtpSend(process.argv.slice(3));
     await flushDirectCliSentry();
     return;
   }
   if (command === "task") {
-    initDirectCliSentry();
+    await initDirectCliSentry();
     await handleTaskCommand(process.argv.slice(3));
     await flushDirectCliSentry();
     return;
   }
   if (command === "agent") {
-    initDirectCliSentry();
+    await initDirectCliSentry();
     await handleAgentCommand(process.argv.slice(3));
     await flushDirectCliSentry();
     return;
   }
   if (command === "file") {
-    initDirectCliSentry();
+    await initDirectCliSentry();
     const { handleFileCommand: handleFileCommand2 } = await Promise.resolve().then(() => (init_file_cli(), file_cli_exports));
     await handleFileCommand2(process.argv.slice(3));
     await flushDirectCliSentry();
     return;
   }
   if (command === "user") {
-    initDirectCliSentry();
+    await initDirectCliSentry();
     const { handleUserCommand: handleUserCommand2 } = await Promise.resolve().then(() => (init_user_attention_cli(), user_attention_cli_exports));
     await handleUserCommand2(process.argv.slice(3));
     await flushDirectCliSentry();
     return;
   }
   if (command === "session") {
-    initDirectCliSentry();
+    await initDirectCliSentry();
     const { handleSessionCommand: handleSessionCommand2 } = await Promise.resolve().then(() => (init_session_cli(), session_cli_exports));
     await handleSessionCommand2(process.argv.slice(3));
     await flushDirectCliSentry();
     return;
   }
   if (command === "xmtp-debug") {
-    initDirectCliSentry();
+    await initDirectCliSentry();
     const { handleXmtpDebugCli: handleXmtpDebugCli2 } = await Promise.resolve().then(() => (init_xmtp_debug_cli(), xmtp_debug_cli_exports));
     await handleXmtpDebugCli2(process.argv.slice(3));
     await flushDirectCliSentry();
     return;
   }
   if (command === "ai") {
-    initDirectCliSentry();
+    await initDirectCliSentry();
     const { handleAiCommand: handleAiCommand2 } = await Promise.resolve().then(() => (init_ai_cli(), ai_cli_exports));
     await handleAiCommand2(process.argv.slice(3));
     await flushDirectCliSentry();
@@ -120083,7 +120452,7 @@ main().then(() => {
   }
   console.error(err2 instanceof Error ? err2.stack ?? err2.message : String(err2));
   try {
-    initDirectCliSentry();
+    await initDirectCliSentry();
     const command = process.argv[2] ?? "status";
     const subcommand = process.argv[3] ?? "";
     logger.error(LogEvent.DIRECT_CLI_FAILED, err2 instanceof Error ? err2 : new Error(String(err2)), directCliSentryExtra(command, {