@xfxstudio/claworld 0.2.5 → 0.2.7

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

@@ -15,6 +15,7 @@ import {
 const DUPLICATE_CONNECTION_CLOSE_CODE = 4001;
 const STALE_CONNECTION_CLOSE_CODE = 4002;
 const TERMINAL_CLOSE_REASONS = new Set(['duplicate_connection_replaced', 'stale_connection']);
+const DEFAULT_REPLY_ACK_TIMEOUT_MS = 5000;
 
 function normalizeRelayWebSocketUrl(serverUrl) {
   const parsed = new URL(serverUrl);
@@ -49,6 +50,90 @@ function buildInboundEnvelope(message = {}) {
   };
 }
 
+function normalizeOptionalText(value) {
+  if (value == null) return null;
+  const normalized = String(value).trim();
+  return normalized || null;
+}
+
+function buildReplyAckTimeoutError({ deliveryId, timeoutMs, context = {} } = {}) {
+  return createRuntimeBoundaryError({
+    code: 'relay_reply_ack_timeout',
+    category: 'transport',
+    status: 504,
+    message: `timed out waiting for relay reply acknowledgement for ${deliveryId || 'unknown-delivery'} after ${timeoutMs}ms`,
+    publicMessage: 'relay reply acknowledgement timed out',
+    recoverable: true,
+    context,
+  });
+}
+
+function buildReplyFallbackError({
+  deliveryId,
+  status,
+  body,
+  context = {},
+} = {}) {
+  return createRuntimeBoundaryError({
+    code: normalizeOptionalText(body?.code) || normalizeOptionalText(body?.error) || 'relay_reply_fallback_failed',
+    category: status >= 500 ? 'runtime' : 'transport',
+    status: Number.isInteger(status) ? status : 502,
+    message: normalizeOptionalText(body?.message) || normalizeOptionalText(body?.reason) || 'relay reply fallback failed',
+    publicMessage: 'relay reply fallback failed',
+    recoverable: status >= 500,
+    context: {
+      deliveryId: normalizeOptionalText(deliveryId),
+      ...context,
+    },
+  });
+}
+
+function buildKeepSilentAckTimeoutError({ deliveryId, timeoutMs, context = {} } = {}) {
+  return createRuntimeBoundaryError({
+    code: 'relay_kept_silent_ack_timeout',
+    category: 'transport',
+    status: 504,
+    message: `timed out waiting for relay kept_silent acknowledgement for ${deliveryId || 'unknown-delivery'} after ${timeoutMs}ms`,
+    publicMessage: 'relay kept_silent acknowledgement timed out',
+    recoverable: true,
+    context,
+  });
+}
+
+function buildKeepSilentFallbackError({
+  deliveryId,
+  status,
+  body,
+  context = {},
+} = {}) {
+  return createRuntimeBoundaryError({
+    code: normalizeOptionalText(body?.code) || normalizeOptionalText(body?.error) || 'relay_kept_silent_fallback_failed',
+    category: status >= 500 ? 'runtime' : 'transport',
+    status: Number.isInteger(status) ? status : 502,
+    message: normalizeOptionalText(body?.message) || normalizeOptionalText(body?.reason) || 'relay kept_silent fallback failed',
+    publicMessage: 'relay kept_silent fallback failed',
+    recoverable: status >= 500,
+    context: {
+      deliveryId: normalizeOptionalText(deliveryId),
+      ...context,
+    },
+  });
+}
+
+function isReplyAlreadyApplied(result = null, deliveryId = null) {
+  if (!result || result.status !== 409) return false;
+  if (normalizeOptionalText(result.body?.reason) !== 'delivery_not_replyable') return false;
+  if (normalizeOptionalText(result.body?.delivery?.deliveryId) !== normalizeOptionalText(deliveryId)) return false;
+  return normalizeOptionalText(result.body?.delivery?.status) === 'replied';
+}
+
+function isDeliveryKeptSilentAlreadyApplied(result = null, deliveryId = null) {
+  if (!result || result.status !== 409) return false;
+  if (normalizeOptionalText(result.body?.reason) !== 'delivery_not_replyable') return false;
+  if (normalizeOptionalText(result.body?.delivery?.deliveryId) !== normalizeOptionalText(deliveryId)) return false;
+  return normalizeOptionalText(result.body?.delivery?.status) === 'kept_silent';
+}
+
 export class ClaworldRelayClient extends EventEmitter {
   constructor({
     logger = console,
@@ -479,7 +564,7 @@ export class ClaworldRelayClient extends EventEmitter {
     config,
     agentId,
     credential = null,
-    clientVersion = 'claworld-plugin/0.1.5',
+    clientVersion = 'claworld-plugin/0.2.7',
     sessionTarget,
     fallbackTarget,
   } = {}) {
@@ -597,6 +682,419 @@ export class ClaworldRelayClient extends EventEmitter {
     });
   }
 
+  sendKeepSilent({ deliveryId, sessionKey, reason = null, source = 'openclaw-autochain' } = {}) {
+    const normalizedDeliveryId = normalizeOptionalText(deliveryId);
+    if (!normalizedDeliveryId) {
+      throw createRuntimeBoundaryError({
+        code: 'relay_delivery_id_required',
+        category: 'input',
+        status: 400,
+        message: 'deliveryId is required to mark relay delivery kept_silent',
+        publicMessage: 'deliveryId is required',
+        recoverable: true,
+      });
+    }
+    const envelope = {
+      deliveryId: normalizedDeliveryId,
+      sessionKey: normalizeOptionalText(sessionKey) || null,
+      reason: normalizeOptionalText(reason) || 'no_renderable_reply',
+      source: normalizeOptionalText(source) || 'openclaw-autochain',
+    };
+    this.send({
+      type: 'kept_silent',
+      deliveryId: envelope.deliveryId,
+      sessionKey: envelope.sessionKey,
+      payload: {
+        reason: envelope.reason,
+        source: envelope.source,
+      },
+    });
+    return envelope;
+  }
+
+  waitForReplyAck({ deliveryId, timeoutMs = DEFAULT_REPLY_ACK_TIMEOUT_MS } = {}) {
+    const normalizedDeliveryId = normalizeOptionalText(deliveryId);
+    if (!normalizedDeliveryId) {
+      return Promise.reject(createRuntimeBoundaryError({
+        code: 'relay_delivery_id_required',
+        category: 'input',
+        status: 400,
+        message: 'deliveryId is required to wait for relay reply acknowledgement',
+        publicMessage: 'deliveryId is required',
+        recoverable: true,
+      }));
+    }
+
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let timeout = null;
+
+      const cleanup = () => {
+        if (timeout) clearTimeout(timeout);
+        this.off('reply.accepted', onReplyAccepted);
+        this.off('disconnect', onDisconnect);
+        this.off('close', onDisconnect);
+      };
+
+      const settleResolve = (value) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolve(value);
+      };
+
+      const settleReject = (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(error);
+      };
+
+      const onReplyAccepted = (message = {}) => {
+        const repliedDeliveryId = normalizeOptionalText(message?.data?.repliedDeliveryId);
+        if (repliedDeliveryId !== normalizedDeliveryId) return;
+        settleResolve(message);
+      };
+
+      const onDisconnect = (info = {}) => {
+        settleReject(createRuntimeBoundaryError({
+          code: 'relay_reply_ack_disconnected',
+          category: 'transport',
+          status: 502,
+          message: `relay websocket closed before reply acknowledgement for ${normalizedDeliveryId}`,
+          publicMessage: 'relay websocket closed before reply acknowledgement',
+          recoverable: true,
+          context: this.buildBoundaryContext({
+            stage: 'reply_ack_wait',
+            deliveryId: normalizedDeliveryId,
+            closeCode: info?.code ?? null,
+            closeReason: info?.reason || null,
+          }),
+        }));
+      };
+
+      this.on('reply.accepted', onReplyAccepted);
+      this.on('disconnect', onDisconnect);
+      this.on('close', onDisconnect);
+
+      timeout = setTimeout(() => {
+        settleReject(buildReplyAckTimeoutError({
+          deliveryId: normalizedDeliveryId,
+          timeoutMs,
+          context: this.buildBoundaryContext({
+            stage: 'reply_ack_wait',
+            deliveryId: normalizedDeliveryId,
+          }),
+        }));
+      }, timeoutMs);
+      if (typeof timeout.unref === 'function') timeout.unref();
+    });
+  }
+
+  waitForKeepSilentAck({ deliveryId, timeoutMs = DEFAULT_REPLY_ACK_TIMEOUT_MS } = {}) {
+    const normalizedDeliveryId = normalizeOptionalText(deliveryId);
+    if (!normalizedDeliveryId) {
+      return Promise.reject(createRuntimeBoundaryError({
+        code: 'relay_delivery_id_required',
+        category: 'input',
+        status: 400,
+        message: 'deliveryId is required to wait for relay kept_silent acknowledgement',
+        publicMessage: 'deliveryId is required',
+        recoverable: true,
+      }));
+    }
+
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let timeout = null;
+
+      const cleanup = () => {
+        if (timeout) clearTimeout(timeout);
+        this.off('kept_silent.accepted', onKeptSilentAccepted);
+        this.off('disconnect', onDisconnect);
+        this.off('close', onDisconnect);
+      };
+
+      const settleResolve = (value) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolve(value);
+      };
+
+      const settleReject = (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(error);
+      };
+
+      const onKeptSilentAccepted = (message = {}) => {
+        const keptSilentDeliveryId = normalizeOptionalText(message?.data?.keptSilentDeliveryId);
+        if (keptSilentDeliveryId !== normalizedDeliveryId) return;
+        settleResolve(message);
+      };
+
+      const onDisconnect = (info = {}) => {
+        settleReject(createRuntimeBoundaryError({
+          code: 'relay_kept_silent_ack_disconnected',
+          category: 'transport',
+          status: 502,
+          message: `relay websocket closed before kept_silent acknowledgement for ${normalizedDeliveryId}`,
+          publicMessage: 'relay websocket closed before kept_silent acknowledgement',
+          recoverable: true,
+          context: this.buildBoundaryContext({
+            stage: 'kept_silent_ack_wait',
+            deliveryId: normalizedDeliveryId,
+            closeCode: info?.code ?? null,
+            closeReason: info?.reason || null,
+          }),
+        }));
+      };
+
+      this.on('kept_silent.accepted', onKeptSilentAccepted);
+      this.on('disconnect', onDisconnect);
+      this.on('close', onDisconnect);
+
+      timeout = setTimeout(() => {
+        settleReject(buildKeepSilentAckTimeoutError({
+          deliveryId: normalizedDeliveryId,
+          timeoutMs,
+          context: this.buildBoundaryContext({
+            stage: 'kept_silent_ack_wait',
+            deliveryId: normalizedDeliveryId,
+          }),
+        }));
+      }, timeoutMs);
+      if (typeof timeout.unref === 'function') timeout.unref();
+    });
+  }
+
+  async replyToDeliveryHttp({ deliveryId, replyText, source = 'subagent' } = {}) {
+    const envelope = this.outbound.createReplyEnvelope({
+      deliveryId,
+      sessionKey: null,
+      replyText,
+      source,
+    });
+    const result = await this.requestJson(`/v1/deliveries/${encodeURIComponent(envelope.deliveryId)}/reply`, {
+      method: 'POST',
+      headers: buildRuntimeAuthHeaders(this.runtimeConfig, { 'content-type': 'application/json' }),
+      body: JSON.stringify({
+        fromAgentId: this.boundAgentId,
+        payload: {
+          ...envelope.payload,
+        },
+      }),
+    }, {
+      code: 'relay_reply_fallback_failed',
+      message: 'failed to submit relay reply fallback',
+      publicMessage: 'failed to submit relay reply fallback',
+    });
+    return {
+      ...result,
+      envelope,
+    };
+  }
+
+  async sendReplyAndWaitForAck({
+    deliveryId,
+    sessionKey,
+    replyText,
+    source = 'subagent',
+    timeoutMs = DEFAULT_REPLY_ACK_TIMEOUT_MS,
+    httpFallback = true,
+  } = {}) {
+    const envelope = this.sendReply({
+      deliveryId,
+      sessionKey,
+      replyText,
+      source,
+    });
+
+    try {
+      const ack = await this.waitForReplyAck({
+        deliveryId: envelope.deliveryId,
+        timeoutMs,
+      });
+      return {
+        ok: true,
+        envelope,
+        ack,
+        transport: 'websocket',
+        fallbackUsed: false,
+      };
+    } 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,
+        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,
+        }),
+      });
+    }
+  }
+
+  async keepDeliverySilentHttp({ deliveryId, reason = null, source = 'openclaw-autochain' } = {}) {
+    const normalizedDeliveryId = normalizeOptionalText(deliveryId);
+    const result = await this.requestJson(`/v1/deliveries/${encodeURIComponent(normalizedDeliveryId)}/kept-silent`, {
+      method: 'POST',
+      headers: buildRuntimeAuthHeaders(this.runtimeConfig, { 'content-type': 'application/json' }),
+      body: JSON.stringify({
+        fromAgentId: this.boundAgentId,
+        reason: normalizeOptionalText(reason) || 'no_renderable_reply',
+        source: normalizeOptionalText(source) || 'openclaw-autochain',
+      }),
+    }, {
+      code: 'relay_kept_silent_fallback_failed',
+      message: 'failed to submit relay kept_silent fallback',
+      publicMessage: 'failed to submit relay kept_silent fallback',
+    });
+    return {
+      ...result,
+      envelope: {
+        deliveryId: normalizedDeliveryId,
+        reason: normalizeOptionalText(reason) || 'no_renderable_reply',
+        source: normalizeOptionalText(source) || 'openclaw-autochain',
+      },
+    };
+  }
+
+  async sendKeepSilentAndWaitForAck({
+    deliveryId,
+    sessionKey,
+    reason = null,
+    source = 'openclaw-autochain',
+    timeoutMs = DEFAULT_REPLY_ACK_TIMEOUT_MS,
+    httpFallback = true,
+  } = {}) {
+    const envelope = this.sendKeepSilent({
+      deliveryId,
+      sessionKey,
+      reason,
+      source,
+    });
+
+    try {
+      const ack = await this.waitForKeepSilentAck({
+        deliveryId: envelope.deliveryId,
+        timeoutMs,
+      });
+      return {
+        ok: true,
+        envelope,
+        ack,
+        transport: 'websocket',
+        fallbackUsed: false,
+      };
+    } 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,
+        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,
+        }),
+      });
+    }
+  }
+
   async createChatRequest({ fromAgentId, toAddress, requestContext = {} } = {}) {
     const target = await this.requestJson(`/v1/agents/resolve?address=${encodeURIComponent(toAddress)}`, {
       method: 'GET',
@@ -618,6 +1116,9 @@ export class ClaworldRelayClient extends EventEmitter {
         kickoffBrief: normalized.kickoffBrief || null,
         openingMessage: normalized.openingMessage || null,
         worldId: normalized.conversation?.worldId || null,
+        requestContext: requestContext && typeof requestContext === 'object' && !Array.isArray(requestContext)
+          ? requestContext
+          : undefined,
       }),
     }, {
       code: 'relay_request_create_failed',

package/src/openclaw/runtime/demo-session-bootstrap.js

@@ -23,8 +23,7 @@ export function createDemoSessionBootstrap() {
           'load demo world',
           'create manual session',
           'inject opening system message',
-          'wait for dual raise or manual stop',
-          'build canonical result',
+          'wait for conversation closure or manual stop',
         ],
         status: 'planned',
       };

package/src/openclaw/runtime/tool-contracts.js

@@ -76,7 +76,7 @@ function projectParticipantContextField(field = null) {
 
 function projectWorldRole(worldRole, fallback = null) {
   const normalized = normalizeText(worldRole, fallback);
-  return ['owner', 'admin', 'member'].includes(normalized) ? normalized : fallback;
+  return ['owner', 'member'].includes(normalized) ? normalized : fallback;
 }
 
 function projectWorldStats(stats = null) {
@@ -622,6 +622,22 @@ function projectChatRequestItem(request = {}) {
   };
 }
 
+function projectChatInboxChatItem(chat = {}) {
+  if (!chat || typeof chat !== 'object' || Array.isArray(chat)) return null;
+  return {
+    chatRequestId: normalizeText(chat.chatRequestId, null),
+    status: normalizeText(chat.status, null),
+    direction: normalizeText(chat.direction, null),
+    createdAt: normalizeText(chat.createdAt, null),
+    updatedAt: normalizeText(chat.updatedAt, null),
+    lastTurnAt: normalizeText(chat.lastTurnAt, null),
+    conversationKey: normalizeText(chat.conversationKey, null),
+    localSessionKey: normalizeText(chat.localSessionKey, normalizeText(chat.sessionKey, null)),
+    counterparty: projectToolAgentSummary(chat.counterparty),
+    conversation: normalizeConversationScopeDetails(chat.conversation),
+  };
+}
+
 export function projectToolFriendRequestMutationResponse(result = {}, { accountId = null } = {}) {
   return {
     status: result.alreadyFriends === true
@@ -690,3 +706,26 @@ export function projectToolChatRequestListResponse(result = {}, { accountId = nu
     items,
   };
 }
+
+export function projectToolChatInboxResponse(result = {}, { accountId = null } = {}) {
+  const pendingRequests = Array.isArray(result.pendingRequests)
+    ? result.pendingRequests.map((request) => projectChatRequestItem(request)).filter(Boolean)
+    : [];
+  const chats = Array.isArray(result.chats)
+    ? result.chats.map((chat) => projectChatInboxChatItem(chat)).filter(Boolean)
+    : [];
+  return {
+    accountId: normalizeText(accountId, null),
+    counts: result.counts && typeof result.counts === 'object' && !Array.isArray(result.counts)
+      ? {
+          pendingRequestCount: normalizeInteger(result.counts.pendingRequestCount, pendingRequests.length),
+          chatCount: normalizeInteger(result.counts.chatCount, chats.length),
+        }
+      : {
+          pendingRequestCount: pendingRequests.length,
+          chatCount: chats.length,
+        },
+    pendingRequests,
+    chats,
+  };
+}

package/src/openclaw/runtime/tool-inventory.js

@@ -2,7 +2,7 @@ export const CLAWORLD_TOOL_CONTRACT_VERSION = 'v1';
 
 export const CLAWORLD_CHAT_REQUEST_TOOL_NAMES = Object.freeze([
   'claworld_request_chat',
-  'claworld_list_chat_requests',
+  'claworld_chat_inbox',
   'claworld_accept_chat_request',
 ]);
 
@@ -22,6 +22,8 @@ export const CLAWORLD_WORLD_TOOL_NAMES = Object.freeze([
 
 export const CLAWORLD_WORLD_ADMIN_PUBLIC_TOOL_NAMES = Object.freeze([
   'claworld_create_world',
+  'claworld_list_owned_worlds',
+  'claworld_manage_world',
 ]);
 
 export const CLAWORLD_COMPATIBILITY_TOOL_NAMES = Object.freeze([
@@ -35,8 +37,6 @@ export const CLAWORLD_RETIRED_PUBLIC_TOOL_NAMES = Object.freeze([
   'claworld_accept_friend_request',
   'claworld_reject_friend_request',
   'claworld_broadcast_world',
-  'claworld_list_owned_worlds',
-  'claworld_manage_world',
   'claworld_resolve_agent',
 ]);
 

package/src/openclaw/runtime/world-moderation-helper.js

@@ -76,7 +76,7 @@ function normalizeWorldStats(stats = null) {
 
 function normalizeWorldRole(worldRole, fallback = null) {
   const normalized = normalizeText(worldRole, fallback);
-  return ['owner', 'admin', 'member'].includes(normalized) ? normalized : fallback;
+  return ['owner', 'member'].includes(normalized) ? normalized : fallback;
 }
 
 function normalizeManagedWorld(payload = {}) {
@@ -207,12 +207,11 @@ export async function createModeratedWorld({
   const baseUrl = normalizeRelayHttpBaseUrl(resolvedRuntimeConfig.serverUrl);
   const created = await fetchJson(fetchImpl, `${baseUrl}/v1/worlds`, {
     method: 'POST',
-    headers: {
+    headers: buildRuntimeAuthHeaders(resolvedRuntimeConfig, {
       accept: 'application/json',
       'content-type': 'application/json',
       ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
-      ...(resolvedRuntimeConfig.relay?.credentialToken ? { 'x-relay-token': resolvedRuntimeConfig.relay.credentialToken } : {}),
-    },
+    }),
     body: JSON.stringify({
       agentId: resolvedAgentId,
       displayName,
@@ -259,11 +258,10 @@ export async function fetchOwnedWorlds({
   requestUrl.searchParams.set('agentId', resolvedAgentId);
   requestUrl.searchParams.set('includeDisabled', includeDisabled ? 'true' : 'false');
   const result = await fetchJson(fetchImpl, requestUrl.toString(), {
-    headers: {
+    headers: buildRuntimeAuthHeaders(resolvedRuntimeConfig, {
       accept: 'application/json',
       ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
-      ...(resolvedRuntimeConfig.relay?.credentialToken ? { 'x-relay-token': resolvedRuntimeConfig.relay.credentialToken } : {}),
-    },
+    }),
   });
 
   if (!result.ok) {
@@ -312,11 +310,10 @@ export async function manageModeratedWorld({
     const requestUrl = new URL(`${baseUrl}/v1/moderation/worlds/${encodeURIComponent(resolvedWorldId)}`);
     requestUrl.searchParams.set('agentId', resolvedAgentId);
     const result = await fetchJson(fetchImpl, requestUrl.toString(), {
-      headers: {
+      headers: buildRuntimeAuthHeaders(resolvedRuntimeConfig, {
         accept: 'application/json',
         ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
-        ...(resolvedRuntimeConfig.relay?.credentialToken ? { 'x-relay-token': resolvedRuntimeConfig.relay.credentialToken } : {}),
-      },
+      }),
     });
 
     if (!result.ok) {
@@ -334,12 +331,11 @@ export async function manageModeratedWorld({
 
   const result = await fetchJson(fetchImpl, `${baseUrl}/v1/moderation/worlds/${encodeURIComponent(resolvedWorldId)}`, {
     method: 'PATCH',
-    headers: {
+    headers: buildRuntimeAuthHeaders(resolvedRuntimeConfig, {
       accept: 'application/json',
       'content-type': 'application/json',
       ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
-      ...(resolvedRuntimeConfig.relay?.credentialToken ? { 'x-relay-token': resolvedRuntimeConfig.relay.credentialToken } : {}),
-    },
+    }),
     body: JSON.stringify({
       agentId: resolvedAgentId,
       ...(changes && typeof changes === 'object' ? { changes } : {}),