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

package/dist/index.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");
@@ -2712,7 +2722,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";
@@ -2842,35 +2852,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 {
@@ -2906,20 +2962,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");
@@ -2927,11 +2979,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 };
@@ -2962,7 +3024,7 @@ async function stopSystemdAutostart() {
   return {
     platform: "linux-systemd",
     path: paths.servicePath,
-    stopped: !missing,
+    stopped: result.ok && !missing,
     ...message ? { message } : {}
   };
 }
@@ -2977,7 +3039,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",
@@ -2987,11 +3049,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",
@@ -3001,6 +3079,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",
@@ -19189,6 +19275,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.
@@ -19725,7 +19812,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(output) {
+  const normalized = output.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;
@@ -19735,6 +19899,7 @@ function applyFatalEventDefaults(event) {
     const target = event;
     target.extra = {
       ...RELEASE_FIELDS,
+      ...RUNTIME_FIELDS,
       ...target.extra ?? {},
       eventName: LogEvent.FATAL_UNCAUGHT,
       eventFamily: "diagnostics",
@@ -19755,6 +19920,9 @@ function applyFatalEventDefaults(event) {
 function isInfoEventAllowlisted(name) {
   return SENTRY_INFO_ALLOWLIST.has(name);
 }
+function isTagKey(key) {
+  return SENTRY_TAG_KEYS.has(key);
+}
 function agentExtras(identity) {
   return {
     walletAddress: identity.walletAddress || UNKNOWN_FIELD,
@@ -19763,7 +19931,7 @@ function agentExtras(identity) {
     role: identity.role != null && identity.role !== "" ? String(identity.role) : UNKNOWN_FIELD
   };
 }
-var Sentry, import_node_crypto3, 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_crypto3, 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";
@@ -19774,6 +19942,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_crypto3.randomUUID)();
@@ -19860,6 +20029,7 @@ var init_sentry_logger = __esm({
     SENTRY_TAG_KEYS = /* @__PURE__ */ new Set([
       "agentId",
       "agentPlatform",
+      "aiProvider",
       "cacheName",
       "causeCode",
       "causeType",
@@ -19882,6 +20052,8 @@ var init_sentry_logger = __esm({
       "kind",
       "method",
       "onchainosAgentId",
+      "onchainosVersion",
+      "onchainosVersionProbeStatus",
       "operation",
       "originPlatform",
       "outcome",
@@ -19898,6 +20070,7 @@ var init_sentry_logger = __esm({
       "role",
       "runId",
       "runtimeContainer",
+      "runtimeSurface",
       "senderAgentId",
       "source",
       "stage",
@@ -19968,6 +20141,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,
@@ -20023,6 +20197,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;
@@ -20042,6 +20217,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,
@@ -20061,6 +20239,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;
@@ -20073,6 +20259,7 @@ var init_sentry_logger = __esm({
           enrichCorrelationFields({
             flowId: FLOW_ID,
             ...RELEASE_FIELDS,
+            ...RUNTIME_FIELDS,
             ...extra ?? {}
           })
         );
@@ -20107,6 +20294,7 @@ var init_sentry_logger = __esm({
           enrichCorrelationFields({
             flowId: FLOW_ID,
             ...RELEASE_FIELDS,
+            ...RUNTIME_FIELDS,
             ...extra ?? {}
           })
         );
@@ -32247,7 +32435,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)
     };
@@ -33188,7 +33376,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;
@@ -33398,7 +33586,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,
@@ -43997,6 +44185,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,
@@ -44080,6 +44273,8 @@ var init_doctor_sentry = __esm({
     "use strict";
     init_sentry_config();
     init_sentry_logger();
+    init_runtime_metadata();
+    init_ai_provider();
     sentryReady = false;
   }
 });
@@ -44200,6 +44395,7 @@ __export(index_exports, {
   createUserAttentionWatchParentMonitor: () => createUserAttentionWatchParentMonitor,
   currentOpenClawGatewaySessionKey: () => currentOpenClawGatewaySessionKey,
   detectAiProviders: () => detectAiProviders,
+  detectAiRuntimeSurface: () => detectAiRuntimeSurface,
   detectCurrentAiProvider: () => detectCurrentAiProvider,
   detectGatewayInvocation: () => detectGatewayInvocation,
   detectMessageEligibleOfflineReplaySupport: () => detectMessageEligibleOfflineReplaySupport,
@@ -44220,6 +44416,7 @@ __export(index_exports, {
   getA2ACapabilities: () => getA2ACapabilities,
   getDaemonStatus: () => getDaemonStatus,
   getHermesGatewayPluginStatus: () => getHermesGatewayPluginStatus,
+  getRuntimeMetadata: () => getRuntimeMetadata,
   getSessionBusyTracker: () => getSessionBusyTracker,
   handleCapabilitiesCommand: () => handleCapabilitiesCommand,
   handleDoctorCommand: () => handleDoctorCommand,
@@ -44247,6 +44444,7 @@ __export(index_exports, {
   isRetryableOpenClawGatewayError: () => isRetryableOpenClawGatewayError,
   isSqliteBusyError: () => isSqliteBusyError,
   isSystemdManagerUnavailableMessage: () => isSystemdManagerUnavailableMessage,
+  isTagKey: () => isTagKey,
   isWindowsElevated: () => isWindowsElevated,
   killProcessTree: () => killProcessTree,
   launchdPlistHasCurrentRestartPolicy: () => launchdPlistHasCurrentRestartPolicy,
@@ -44258,16 +44456,19 @@ __export(index_exports, {
   messageEligibleHelpAdvertisesOfflineReplay: () => messageEligibleHelpAdvertisesOfflineReplay,
   nodeVersionSatisfies: () => nodeVersionSatisfies,
   normalizeAiProvider: () => normalizeAiProvider,
+  normalizeAiRuntimeProvider: () => normalizeAiRuntimeProvider,
   normalizeHermesOkxA2aPluginConfig: () => normalizeHermesOkxA2aPluginConfig,
   notifyAgentMessageToUserAttention: () => notifyAgentMessageToUserAttention,
   notifyDirectToUserAttention: () => notifyDirectToUserAttention,
   notifySystemMessageToUser: () => notifySystemMessageToUser,
   notifyUserAttentionChanged: () => notifyUserAttentionChanged,
   parseLogsExportArgs: () => parseLogsExportArgs,
+  parseOnchainosVersionOutput: () => parseOnchainosVersionOutput,
   parsePluginYamlVersion: () => parsePluginYamlVersion,
   parseWalletLoginStatus: () => parseWalletLoginStatus,
   parseWindowsParentProcessJson: () => parseWindowsParentProcessJson,
   performRuntimeSwitch: () => performRuntimeSwitch,
+  persistAiRuntimeSurfaceBestEffort: () => persistAiRuntimeSurfaceBestEffort,
   persistCurrentRuntimeSelectionForNewJob: () => persistCurrentRuntimeSelectionForNewJob,
   pickOnchainosWin32Candidate: () => pickOnchainosWin32Candidate,
   prepareAndBindCurrentRuntimeForNewJob: () => prepareAndBindCurrentRuntimeForNewJob,
@@ -44277,11 +44478,13 @@ __export(index_exports, {
   processFileMessage: () => processFileMessage,
   queryWalletLoginStatus: () => queryWalletLoginStatus,
   readAiProviderTimeoutMs: () => readAiProviderTimeoutMs,
+  readAiRuntimeSurfaceBestEffort: () => readAiRuntimeSurfaceBestEffort,
   readCachedCodexReadiness: () => readCachedCodexReadiness,
   readLastLines: () => readLastLines,
   readParentProcessCommandForPlatform: () => readParentProcessCommandForPlatform,
   readUserAttentionWatcherEvent: () => readUserAttentionWatcherEvent,
   refreshAgentsAndWait: () => refreshAgentsAndWait,
+  refreshOnchainosVersionMetadata: () => refreshOnchainosVersionMetadata,
   registerUserAttentionWatcher: () => registerUserAttentionWatcher,
   releaseActiveDaemon: () => releaseActiveDaemon,
   removeUserAttentionWatcher: () => removeUserAttentionWatcher,
@@ -44323,8 +44526,10 @@ __export(index_exports, {
   runDoctor: () => runDoctor,
   runHeartbeatRefreshCycle: () => runHeartbeatRefreshCycle,
   runListener: () => runListener,
+  runtimeMetadataFields: () => runtimeMetadataFields,
   scanUserAttentionWatchers: () => scanUserAttentionWatchers,
   setOpenClawWebSocketFactoryForTests: () => setOpenClawWebSocketFactoryForTests,
+  setRuntimeMetadata: () => setRuntimeMetadata,
   shouldDelegateToSupervisor: () => shouldDelegateToSupervisor,
   shouldRouteThroughWindowsShell: () => shouldRouteThroughWindowsShell,
   spawnCompat: () => spawnCompat,
@@ -44336,6 +44541,7 @@ __export(index_exports, {
   startUserAttentionWatcherCoordinator: () => startUserAttentionWatcherCoordinator,
   stopDaemon: () => stopDaemon,
   stopOpenClawGateway: () => stopOpenClawGateway,
+  stopSystemdAutostart: () => stopSystemdAutostart,
   subscribeUserAttentionEvents: () => subscribeUserAttentionEvents,
   summarizeXmtpTestEvents: () => summarizeXmtpTestEvents,
   switchProvider: () => switchProvider,
@@ -45361,6 +45567,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 ?? "",
@@ -45680,6 +45888,7 @@ var AiRunner = class {
       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,
@@ -58850,14 +59059,99 @@ var import_node_child_process6 = require("node:child_process");
 var import_node_path22 = require("node:path");
 var import_node_util2 = require("node:util");
 init_sentry_logger();
+init_runtime_metadata();
 init_win_compat();
 var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process6.execFile);
 var resolvedBin = null;
+var versionProbeInFlight = null;
 var REDACTED_VALUE_FLAGS = /* @__PURE__ */ new Set(["--message"]);
+var ONCHAINOS_VERSION_PROBE_TIMEOUT_MS = 5e3;
+var ONCHAINOS_BIN_RESOLVE_TIMEOUT_MS = 5e3;
 function resetResolvedOnchainosBinForTests() {
   resolvedBin = null;
+  versionProbeInFlight = null;
+}
+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 resolve6(
+        options.resolveTimeoutMs ?? ONCHAINOS_BIN_RESOLVE_TIMEOUT_MS
+      );
+      const output = options.runVersionCommand ? await options.runVersionCommand(bin) : await runVersionCommand(bin);
+      const version3 = parseOnchainosVersionOutput(output);
+      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 resolve6() {
+async function resolve6(timeoutMs) {
   if (resolvedBin) {
     return resolvedBin;
   }
@@ -58877,7 +59171,8 @@ async function resolve6() {
     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) {
@@ -60638,7 +60933,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
@@ -60649,7 +60944,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 } : {}
@@ -66397,7 +66692,47 @@ function userWatchEventDeliveredSentryExtra(event) {
 // src/listener.ts
 init_daemon_lock();
 init_ai_provider();
+
+// 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;
+  }
+}
+
+// src/listener.ts
 init_sentry_logger();
+init_runtime_metadata();
 init_sentry_config();
 var DEFAULT_OFFLINE_REPLAY_INTERVAL_SEC = 300;
 var DEFAULT_XMTP_CLIENT_RECYCLE_INTERVAL_SEC = 6 * 60 * 60;
@@ -66408,8 +66743,9 @@ var AUTH_RECOVERY_REFRESH_BACKOFF_MS = [6e4, 12e4, 3e5];
 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 };
 }
 var AgentRefreshAuthGate = class {
   authBlocked = false;
@@ -66836,15 +67172,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,
@@ -66859,7 +67205,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(
@@ -67117,6 +67463,7 @@ async function runListenerWithLock(options, paths) {
     timer = setInterval(() => {
       void runHeartbeatRefreshCycle({
         heartbeat: heartbeatTick,
+        versionRefresh: refreshOnchainosVersionMetadata,
         refresh: syncTick
       });
     }, intervalSec * 1e3);
@@ -67221,7 +67568,8 @@ async function runListenerWithLock(options, paths) {
     });
   }, AUTH_RECOVERY_PROBE_INTERVAL_MS);
   void runHeartbeatRefreshCycle({
-    heartbeat: heartbeatTick
+    heartbeat: heartbeatTick,
+    versionRefresh: refreshOnchainosVersionMetadata
   });
   const commandProcessor = startCommandProcessor({
     service,
@@ -68204,6 +68552,7 @@ var JOB_PROVIDER_BINDING_SOURCES = [
 
 // src/index.ts
 init_sentry_logger();
+init_runtime_metadata();
 init_update_cli();
 init_win_spawn();
 
@@ -69557,7 +69906,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,
@@ -70462,6 +70811,7 @@ async function refreshAgentsAndWait(timeoutMs = 6e4) {
 init_ai_provider();
 init_sentry_logger();
 init_log_fields();
+init_runtime_metadata();
 var RUNTIME_SWITCH_COMPONENT = "node_runtime_switch";
 async function performRuntimeSwitch(store, options = {}) {
   const result = await switchProviderWithReadinessGate({
@@ -70475,11 +70825,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,
@@ -71424,7 +71788,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,
@@ -71758,6 +72122,7 @@ init_autostart_windows();
   createUserAttentionWatchParentMonitor,
   currentOpenClawGatewaySessionKey,
   detectAiProviders,
+  detectAiRuntimeSurface,
   detectCurrentAiProvider,
   detectGatewayInvocation,
   detectMessageEligibleOfflineReplaySupport,
@@ -71778,6 +72143,7 @@ init_autostart_windows();
   getA2ACapabilities,
   getDaemonStatus,
   getHermesGatewayPluginStatus,
+  getRuntimeMetadata,
   getSessionBusyTracker,
   handleCapabilitiesCommand,
   handleDoctorCommand,
@@ -71805,6 +72171,7 @@ init_autostart_windows();
   isRetryableOpenClawGatewayError,
   isSqliteBusyError,
   isSystemdManagerUnavailableMessage,
+  isTagKey,
   isWindowsElevated,
   killProcessTree,
   launchdPlistHasCurrentRestartPolicy,
@@ -71816,16 +72183,19 @@ init_autostart_windows();
   messageEligibleHelpAdvertisesOfflineReplay,
   nodeVersionSatisfies,
   normalizeAiProvider,
+  normalizeAiRuntimeProvider,
   normalizeHermesOkxA2aPluginConfig,
   notifyAgentMessageToUserAttention,
   notifyDirectToUserAttention,
   notifySystemMessageToUser,
   notifyUserAttentionChanged,
   parseLogsExportArgs,
+  parseOnchainosVersionOutput,
   parsePluginYamlVersion,
   parseWalletLoginStatus,
   parseWindowsParentProcessJson,
   performRuntimeSwitch,
+  persistAiRuntimeSurfaceBestEffort,
   persistCurrentRuntimeSelectionForNewJob,
   pickOnchainosWin32Candidate,
   prepareAndBindCurrentRuntimeForNewJob,
@@ -71835,11 +72205,13 @@ init_autostart_windows();
   processFileMessage,
   queryWalletLoginStatus,
   readAiProviderTimeoutMs,
+  readAiRuntimeSurfaceBestEffort,
   readCachedCodexReadiness,
   readLastLines,
   readParentProcessCommandForPlatform,
   readUserAttentionWatcherEvent,
   refreshAgentsAndWait,
+  refreshOnchainosVersionMetadata,
   registerUserAttentionWatcher,
   releaseActiveDaemon,
   removeUserAttentionWatcher,
@@ -71881,8 +72253,10 @@ init_autostart_windows();
   runDoctor,
   runHeartbeatRefreshCycle,
   runListener,
+  runtimeMetadataFields,
   scanUserAttentionWatchers,
   setOpenClawWebSocketFactoryForTests,
+  setRuntimeMetadata,
   shouldDelegateToSupervisor,
   shouldRouteThroughWindowsShell,
   spawnCompat,
@@ -71894,6 +72268,7 @@ init_autostart_windows();
   startUserAttentionWatcherCoordinator,
   stopDaemon,
   stopOpenClawGateway,
+  stopSystemdAutostart,
   subscribeUserAttentionEvents,
   summarizeXmtpTestEvents,
   switchProvider,