@xfxstudio/claworld 2026.4.30-testing.2 → 2026.4.30-testing.3

package/src/openclaw/plugin/relay-client.js

@@ -557,19 +557,23 @@ export class ClaworldRelayClient extends EventEmitter {
     this.heartbeatTimer = null;
   }
 
+  buildWsNotConnectedError(stage = 'send') {
+    return createRuntimeBoundaryError({
+      code: 'relay_ws_not_connected',
+      category: 'transport',
+      status: 409,
+      message: 'relay websocket is not connected',
+      publicMessage: 'relay websocket is not connected',
+      recoverable: true,
+      context: this.buildBoundaryContext({
+        stage,
+      }),
+    });
+  }
+
   send(payload) {
     if (!this.ws || this.ws.readyState !== 1) {
-      throw createRuntimeBoundaryError({
-        code: 'relay_ws_not_connected',
-        category: 'transport',
-        status: 409,
-        message: 'relay websocket is not connected',
-        publicMessage: 'relay websocket is not connected',
-        recoverable: true,
-        context: this.buildBoundaryContext({
-          stage: 'send',
-        }),
-      });
+      throw this.buildWsNotConnectedError('send');
     }
     this.ws.send(JSON.stringify(payload));
   }
@@ -663,7 +667,7 @@ export class ClaworldRelayClient extends EventEmitter {
     return envelope;
   }
 
-  waitForReplyAck({ deliveryId, timeoutMs = DEFAULT_REPLY_ACK_TIMEOUT_MS } = {}) {
+  waitForReplyAck({ deliveryId, timeoutMs = DEFAULT_REPLY_ACK_TIMEOUT_MS, signal = null } = {}) {
     const normalizedDeliveryId = normalizeOptionalText(deliveryId);
     if (!normalizedDeliveryId) {
       return Promise.reject(createRuntimeBoundaryError({
@@ -675,6 +679,20 @@ export class ClaworldRelayClient extends EventEmitter {
         recoverable: true,
       }));
     }
+    if (signal?.aborted) {
+      return Promise.reject(createRuntimeBoundaryError({
+        code: 'relay_reply_ack_wait_cancelled',
+        category: 'transport',
+        status: 499,
+        message: `relay reply acknowledgement wait cancelled for ${normalizedDeliveryId}`,
+        publicMessage: 'relay reply acknowledgement wait cancelled',
+        recoverable: true,
+        context: this.buildBoundaryContext({
+          stage: 'reply_ack_wait',
+          deliveryId: normalizedDeliveryId,
+        }),
+      }));
+    }
 
     return new Promise((resolve, reject) => {
       let settled = false;
@@ -686,6 +704,7 @@ export class ClaworldRelayClient extends EventEmitter {
         this.off('command.accepted', onCommandAccepted);
         this.off('disconnect', onDisconnect);
         this.off('close', onDisconnect);
+        signal?.removeEventListener('abort', onAbort);
       };
 
       const settleResolve = (value) => {
@@ -739,10 +758,26 @@ export class ClaworldRelayClient extends EventEmitter {
         }));
       };
 
+      const onAbort = () => {
+        settleReject(createRuntimeBoundaryError({
+          code: 'relay_reply_ack_wait_cancelled',
+          category: 'transport',
+          status: 499,
+          message: `relay reply acknowledgement wait cancelled for ${normalizedDeliveryId}`,
+          publicMessage: 'relay reply acknowledgement wait cancelled',
+          recoverable: true,
+          context: this.buildBoundaryContext({
+            stage: 'reply_ack_wait',
+            deliveryId: normalizedDeliveryId,
+          }),
+        }));
+      };
+
       this.on('reply.accepted', onReplyAccepted);
       this.on('command.accepted', onCommandAccepted);
       this.on('disconnect', onDisconnect);
       this.on('close', onDisconnect);
+      signal?.addEventListener('abort', onAbort, { once: true });
 
       timeout = setTimeout(() => {
         settleReject(buildReplyAckTimeoutError({
@@ -837,7 +872,7 @@ export class ClaworldRelayClient extends EventEmitter {
     });
   }
 
-  waitForKeepSilentAck({ deliveryId, timeoutMs = DEFAULT_REPLY_ACK_TIMEOUT_MS } = {}) {
+  waitForKeepSilentAck({ deliveryId, timeoutMs = DEFAULT_REPLY_ACK_TIMEOUT_MS, signal = null } = {}) {
     const normalizedDeliveryId = normalizeOptionalText(deliveryId);
     if (!normalizedDeliveryId) {
       return Promise.reject(createRuntimeBoundaryError({
@@ -849,6 +884,20 @@ export class ClaworldRelayClient extends EventEmitter {
         recoverable: true,
       }));
     }
+    if (signal?.aborted) {
+      return Promise.reject(createRuntimeBoundaryError({
+        code: 'relay_kept_silent_ack_wait_cancelled',
+        category: 'transport',
+        status: 499,
+        message: `relay kept_silent acknowledgement wait cancelled for ${normalizedDeliveryId}`,
+        publicMessage: 'relay kept_silent acknowledgement wait cancelled',
+        recoverable: true,
+        context: this.buildBoundaryContext({
+          stage: 'kept_silent_ack_wait',
+          deliveryId: normalizedDeliveryId,
+        }),
+      }));
+    }
 
     return new Promise((resolve, reject) => {
       let settled = false;
@@ -859,6 +908,7 @@ export class ClaworldRelayClient extends EventEmitter {
         this.off('kept_silent.accepted', onKeptSilentAccepted);
         this.off('disconnect', onDisconnect);
         this.off('close', onDisconnect);
+        signal?.removeEventListener('abort', onAbort);
       };
 
       const settleResolve = (value) => {
@@ -898,9 +948,25 @@ export class ClaworldRelayClient extends EventEmitter {
         }));
       };
 
+      const onAbort = () => {
+        settleReject(createRuntimeBoundaryError({
+          code: 'relay_kept_silent_ack_wait_cancelled',
+          category: 'transport',
+          status: 499,
+          message: `relay kept_silent acknowledgement wait cancelled for ${normalizedDeliveryId}`,
+          publicMessage: 'relay kept_silent acknowledgement wait cancelled',
+          recoverable: true,
+          context: this.buildBoundaryContext({
+            stage: 'kept_silent_ack_wait',
+            deliveryId: normalizedDeliveryId,
+          }),
+        }));
+      };
+
       this.on('kept_silent.accepted', onKeptSilentAccepted);
       this.on('disconnect', onDisconnect);
       this.on('close', onDisconnect);
+      signal?.addEventListener('abort', onAbort, { once: true });
 
       timeout = setTimeout(() => {
         settleReject(buildKeepSilentAckTimeoutError({
@@ -943,6 +1009,69 @@ export class ClaworldRelayClient extends EventEmitter {
     };
   }
 
+  async submitReplyHttpFallback({
+    deliveryId,
+    sessionKey,
+    replyText,
+    source = 'subagent',
+    error = null,
+  } = {}) {
+    this.logger.warn?.('[claworld:relay-client] reply websocket transport failed; attempting HTTP fallback', {
+      accountId: this.runtimeConfig?.accountId || null,
+      agentId: this.boundAgentId,
+      deliveryId: normalizeOptionalText(deliveryId),
+      sessionKey: normalizeOptionalText(sessionKey) || null,
+      error: error?.message || String(error),
+    });
+
+    const fallbackResult = await this.replyToDeliveryHttp({
+      deliveryId,
+      replyText,
+      source,
+    });
+
+    if (fallbackResult.status >= 200 && fallbackResult.status < 300) {
+      return {
+        ok: true,
+        envelope: fallbackResult.envelope,
+        ack: {
+          event: 'reply.accepted',
+          data: fallbackResult.body,
+        },
+        transport: 'http',
+        fallbackUsed: true,
+      };
+    }
+
+    if (isReplyAlreadyApplied(fallbackResult, fallbackResult.envelope.deliveryId)) {
+      return {
+        ok: true,
+        envelope: fallbackResult.envelope,
+        ack: {
+          event: 'reply.accepted',
+          data: {
+            ...(fallbackResult.body && typeof fallbackResult.body === 'object' ? fallbackResult.body : {}),
+            repliedDeliveryId: fallbackResult.envelope.deliveryId,
+          },
+        },
+        transport: 'http-already-applied',
+        fallbackUsed: true,
+      };
+    }
+
+    throw buildReplyFallbackError({
+      deliveryId: fallbackResult.envelope.deliveryId,
+      status: fallbackResult.status,
+      body: fallbackResult.body,
+      context: this.buildBoundaryContext({
+        stage: 'reply_fallback',
+        deliveryId: fallbackResult.envelope.deliveryId,
+        sessionKey: normalizeOptionalText(sessionKey) || null,
+        fallbackFrom: error?.code || error?.message || null,
+      }),
+    });
+  }
+
   async acceptDeliveryHttp({ deliveryId, sessionKey = null, source = 'runtime_dispatch' } = {}) {
     const normalizedDeliveryId = normalizeOptionalText(deliveryId);
     const result = await this.requestJsonWithDeliveryVisibilityRetry(`/v1/runtime-deliveries/${encodeURIComponent(normalizedDeliveryId)}/accepted`, {
@@ -976,16 +1105,43 @@ export class ClaworldRelayClient extends EventEmitter {
     timeoutMs = DEFAULT_REPLY_ACK_TIMEOUT_MS,
     httpFallback = true,
   } = {}) {
+    if (httpFallback && (!this.ws || this.ws.readyState !== 1)) {
+      return await this.submitReplyHttpFallback({
+        deliveryId,
+        sessionKey,
+        replyText,
+        source,
+        error: this.buildWsNotConnectedError('reply_send'),
+      });
+    }
+
+    const ackAbortController = new AbortController();
     const ackPromise = this.waitForReplyAck({
       deliveryId,
       timeoutMs,
+      signal: ackAbortController.signal,
     });
-    const envelope = this.sendReply({
-      deliveryId,
-      sessionKey,
-      replyText,
-      source,
-    });
+    let envelope;
+
+    try {
+      envelope = this.sendReply({
+        deliveryId,
+        sessionKey,
+        replyText,
+        source,
+      });
+    } catch (error) {
+      ackAbortController.abort();
+      void ackPromise.catch(() => {});
+      if (!httpFallback) throw error;
+      return await this.submitReplyHttpFallback({
+        deliveryId,
+        sessionKey,
+        replyText,
+        source,
+        error,
+      });
+    }
 
     try {
       const ack = await ackPromise;
@@ -999,59 +1155,12 @@ export class ClaworldRelayClient extends EventEmitter {
     } catch (error) {
       if (!httpFallback) throw error;
 
-      this.logger.warn?.('[claworld:relay-client] reply websocket acknowledgement failed; attempting HTTP fallback', {
-        accountId: this.runtimeConfig?.accountId || null,
-        agentId: this.boundAgentId,
+      return await this.submitReplyHttpFallback({
         deliveryId: envelope.deliveryId,
         sessionKey: envelope.sessionKey,
-        error: error?.message || String(error),
-      });
-
-      const fallbackResult = await this.replyToDeliveryHttp({
-        deliveryId: envelope.deliveryId,
         replyText,
         source,
-      });
-
-      if (fallbackResult.status >= 200 && fallbackResult.status < 300) {
-        return {
-          ok: true,
-          envelope,
-          ack: {
-            event: 'reply.accepted',
-            data: fallbackResult.body,
-          },
-          transport: 'http',
-          fallbackUsed: true,
-        };
-      }
-
-      if (isReplyAlreadyApplied(fallbackResult, envelope.deliveryId)) {
-        return {
-          ok: true,
-          envelope,
-          ack: {
-            event: 'reply.accepted',
-            data: {
-              ...(fallbackResult.body && typeof fallbackResult.body === 'object' ? fallbackResult.body : {}),
-              repliedDeliveryId: envelope.deliveryId,
-            },
-          },
-          transport: 'http-already-applied',
-          fallbackUsed: true,
-        };
-      }
-
-      throw buildReplyFallbackError({
-        deliveryId: envelope.deliveryId,
-        status: fallbackResult.status,
-        body: fallbackResult.body,
-        context: this.buildBoundaryContext({
-          stage: 'reply_fallback',
-          deliveryId: envelope.deliveryId,
-          sessionKey: envelope.sessionKey,
-          fallbackFrom: error?.code || error?.message || null,
-        }),
+        error,
       });
     }
   }
@@ -1169,6 +1278,69 @@ export class ClaworldRelayClient extends EventEmitter {
     };
   }
 
+  async submitKeepSilentHttpFallback({
+    deliveryId,
+    sessionKey,
+    reason = null,
+    source = 'openclaw-autochain',
+    error = null,
+  } = {}) {
+    this.logger.warn?.('[claworld:relay-client] kept_silent websocket transport failed; attempting HTTP fallback', {
+      accountId: this.runtimeConfig?.accountId || null,
+      agentId: this.boundAgentId,
+      deliveryId: normalizeOptionalText(deliveryId),
+      sessionKey: normalizeOptionalText(sessionKey) || null,
+      error: error?.message || String(error),
+    });
+
+    const fallbackResult = await this.keepDeliverySilentHttp({
+      deliveryId,
+      reason,
+      source,
+    });
+
+    if (fallbackResult.status >= 200 && fallbackResult.status < 300) {
+      return {
+        ok: true,
+        envelope: fallbackResult.envelope,
+        ack: {
+          event: 'kept_silent.accepted',
+          data: fallbackResult.body,
+        },
+        transport: 'http',
+        fallbackUsed: true,
+      };
+    }
+
+    if (isDeliveryKeptSilentAlreadyApplied(fallbackResult, fallbackResult.envelope.deliveryId)) {
+      return {
+        ok: true,
+        envelope: fallbackResult.envelope,
+        ack: {
+          event: 'kept_silent.accepted',
+          data: {
+            ...(fallbackResult.body && typeof fallbackResult.body === 'object' ? fallbackResult.body : {}),
+            keptSilentDeliveryId: fallbackResult.envelope.deliveryId,
+          },
+        },
+        transport: 'http-already-applied',
+        fallbackUsed: true,
+      };
+    }
+
+    throw buildKeepSilentFallbackError({
+      deliveryId: fallbackResult.envelope.deliveryId,
+      status: fallbackResult.status,
+      body: fallbackResult.body,
+      context: this.buildBoundaryContext({
+        stage: 'kept_silent_fallback',
+        deliveryId: fallbackResult.envelope.deliveryId,
+        sessionKey: normalizeOptionalText(sessionKey) || null,
+        fallbackFrom: error?.code || error?.message || null,
+      }),
+    });
+  }
+
   async sendKeepSilentAndWaitForAck({
     deliveryId,
     sessionKey,
@@ -1177,16 +1349,43 @@ export class ClaworldRelayClient extends EventEmitter {
     timeoutMs = DEFAULT_REPLY_ACK_TIMEOUT_MS,
     httpFallback = true,
   } = {}) {
+    if (httpFallback && (!this.ws || this.ws.readyState !== 1)) {
+      return await this.submitKeepSilentHttpFallback({
+        deliveryId,
+        sessionKey,
+        reason,
+        source,
+        error: this.buildWsNotConnectedError('kept_silent_send'),
+      });
+    }
+
+    const ackAbortController = new AbortController();
     const ackPromise = this.waitForKeepSilentAck({
       deliveryId,
       timeoutMs,
+      signal: ackAbortController.signal,
     });
-    const envelope = this.sendKeepSilent({
-      deliveryId,
-      sessionKey,
-      reason,
-      source,
-    });
+    let envelope;
+
+    try {
+      envelope = this.sendKeepSilent({
+        deliveryId,
+        sessionKey,
+        reason,
+        source,
+      });
+    } catch (error) {
+      ackAbortController.abort();
+      void ackPromise.catch(() => {});
+      if (!httpFallback) throw error;
+      return await this.submitKeepSilentHttpFallback({
+        deliveryId,
+        sessionKey,
+        reason,
+        source,
+        error,
+      });
+    }
 
     try {
       const ack = await ackPromise;
@@ -1200,59 +1399,12 @@ export class ClaworldRelayClient extends EventEmitter {
     } catch (error) {
       if (!httpFallback) throw error;
 
-      this.logger.warn?.('[claworld:relay-client] kept_silent websocket acknowledgement failed; attempting HTTP fallback', {
-        accountId: this.runtimeConfig?.accountId || null,
-        agentId: this.boundAgentId,
+      return await this.submitKeepSilentHttpFallback({
         deliveryId: envelope.deliveryId,
         sessionKey: envelope.sessionKey,
-        error: error?.message || String(error),
-      });
-
-      const fallbackResult = await this.keepDeliverySilentHttp({
-        deliveryId: envelope.deliveryId,
         reason: envelope.reason,
         source: envelope.source,
-      });
-
-      if (fallbackResult.status >= 200 && fallbackResult.status < 300) {
-        return {
-          ok: true,
-          envelope,
-          ack: {
-            event: 'kept_silent.accepted',
-            data: fallbackResult.body,
-          },
-          transport: 'http',
-          fallbackUsed: true,
-        };
-      }
-
-      if (isDeliveryKeptSilentAlreadyApplied(fallbackResult, envelope.deliveryId)) {
-        return {
-          ok: true,
-          envelope,
-          ack: {
-            event: 'kept_silent.accepted',
-            data: {
-              ...(fallbackResult.body && typeof fallbackResult.body === 'object' ? fallbackResult.body : {}),
-              keptSilentDeliveryId: envelope.deliveryId,
-            },
-          },
-          transport: 'http-already-applied',
-          fallbackUsed: true,
-        };
-      }
-
-      throw buildKeepSilentFallbackError({
-        deliveryId: envelope.deliveryId,
-        status: fallbackResult.status,
-        body: fallbackResult.body,
-        context: this.buildBoundaryContext({
-          stage: 'kept_silent_fallback',
-          deliveryId: envelope.deliveryId,
-          sessionKey: envelope.sessionKey,
-          fallbackFrom: error?.code || error?.message || null,
-        }),
+        error,
       });
     }
   }

package/src/openclaw/protocol/relay-event-protocol.js

@@ -1,15 +1,6 @@
 export const CLAWORLD_PLUGIN_BRIDGE_PROTOCOL = 'claworld.delivery_reply.v1';
 
 const DELIVERY_EVENT_TYPE = 'delivery';
-const MANAGEMENT_EVENT_TYPES = new Set([
-  'notification',
-  'domain_notification',
-  'management_wake',
-  'management_tick',
-  'conversation_lifecycle',
-  'platform_recommendation',
-  'ops_recommendation',
-]);
 
 function normalizeText(value, fallback = null) {
   if (value == null) return fallback;
@@ -25,28 +16,27 @@ function normalizePayload(payload = null) {
 export function createRelayEventProtocol() {
   return {
     version: CLAWORLD_PLUGIN_BRIDGE_PROTOCOL,
-    eventTypes: [DELIVERY_EVENT_TYPE, ...MANAGEMENT_EVENT_TYPES],
-    requiredEnvelopeFields: ['eventType', 'sessionKey', 'payload'],
+    eventTypes: [DELIVERY_EVENT_TYPE],
+    requiredEnvelopeFields: ['eventType', 'deliveryId', 'sessionKey', 'payload'],
     describeEvent(event = {}) {
       const payload = normalizePayload(event.payload);
       const missing = [];
-      const eventType = normalizeText(event.eventType, null);
-      if (eventType !== DELIVERY_EVENT_TYPE && !MANAGEMENT_EVENT_TYPES.has(eventType)) {
+      if (normalizeText(event.eventType, null) !== DELIVERY_EVENT_TYPE) {
         missing.push('eventType');
       }
-      if (eventType === DELIVERY_EVENT_TYPE && !normalizeText(event.deliveryId, null)) {
+      if (!normalizeText(event.deliveryId, null)) {
         missing.push('deliveryId');
       }
       if (!normalizeText(event.sessionKey, null)) {
         missing.push('sessionKey');
       }
-      if (eventType === DELIVERY_EVENT_TYPE && !normalizeText(payload.text, null)) {
+      if (!normalizeText(payload.text, null)) {
         missing.push('payload.text');
       }
       return {
         ok: missing.length === 0,
         missing,
-        role: eventType === DELIVERY_EVENT_TYPE ? 'delivery' : 'management',
+        role: 'delivery',
       };
     },
   };

package/src/openclaw/runtime/session-routing.js

@@ -47,6 +47,10 @@ export function buildConversationSessionKey(conversationKey = null, fallbackSess
 export function resolveRuntimeSessionTarget(event = {}, options = {}) {
   const payload = normalizePayload(event.payload);
   const eventType = normalizeText(event.eventType || event.type || payload.eventType, null);
+  const providedSessionKind = normalizeText(
+    event.sessionKind,
+    normalizeText(payload.sessionKind, normalizeText(options.sessionKind, null)),
+  );
   const targetAgentId = normalizeText(
     event.targetAgentId,
     normalizeText(payload.targetAgentId, normalizeText(options.targetAgentId, null)),
@@ -60,15 +64,15 @@ export function resolveRuntimeSessionTarget(event = {}, options = {}) {
     normalizeText(payload.sessionKey, normalizeText(options.sessionKey, null)),
   );
 
-  if (CLAWORLD_MANAGEMENT_EVENT_TYPES.includes(eventType)) {
+  if (providedSessionKind === CLAWORLD_SESSION_KINDS.management || CLAWORLD_MANAGEMENT_EVENT_TYPES.includes(eventType)) {
     const managementSessionKey = normalizeText(
       options.managementSessionKey,
-      buildManagementSessionKey(targetAgentId),
+      normalizeText(providedSessionKey, buildManagementSessionKey(targetAgentId)),
     );
     return {
       sessionKind: CLAWORLD_SESSION_KINDS.management,
       target: normalizeText(options.managementTarget, 'management_session'),
-      sessionKey: managementSessionKey || providedSessionKey,
+      sessionKey: providedSessionKey || managementSessionKey,
       managementSessionKey: managementSessionKey || null,
       conversationSessionKey: conversationKey ? buildConversationSessionKey(conversationKey) : null,
       targetAgentId,