@xfxstudio/claworld 2026.4.30-testing.2 → 2026.5.3-testing.1

package/src/openclaw/plugin/register-tooling.js

@@ -653,7 +653,19 @@ export function projectToolAccountViewResponse({
   identityPayload = null,
 } = {}) {
   const identityReady = identityPayload?.ready === true;
-  const ready = pairingPayload?.status === 'paired' && identityReady;
+  const activationReady = pairingPayload?.status === 'paired';
+  const bindingReady = typeof pairingPayload?.bindingReady === 'boolean'
+    ? pairingPayload.bindingReady
+    : activationReady;
+  const bindingStatus = normalizeText(
+    pairingPayload?.bindingStatus,
+    activationReady
+      ? (bindingReady ? 'bound' : 'identity_unresolved')
+      : 'unactivated',
+  );
+  const ready = activationReady && identityReady;
+  const relayResolved = pairingPayload?.relayAgent?.resolved ?? null;
+  const relayOnline = pairingPayload?.relayAgent?.online ?? null;
   const resolvedShareCard = identityPayload && Object.prototype.hasOwnProperty.call(identityPayload, 'shareCard')
     ? projectToolShareCard(identityPayload.shareCard)
     : undefined;
@@ -668,7 +680,15 @@ export function projectToolAccountViewResponse({
     reason: normalizeText(pairingPayload?.reason, null),
     bindingSource: normalizeText(pairingPayload?.bindingSource, null),
     activation: {
-      status: pairingPayload?.status === 'paired' ? 'ready' : 'pending',
+      status: activationReady ? 'ready' : 'pending',
+    },
+    diagnostics: {
+      toolReachable: true,
+      bindingReady,
+      bindingStatus,
+      publicIdentityReady: identityReady,
+      relayPresenceResolved: relayResolved,
+      relayOnline,
     },
     relay: {
       agentId: normalizeText(
@@ -678,9 +698,9 @@ export function projectToolAccountViewResponse({
       displayName: normalizeText(pairingPayload?.relayAgent?.displayName, null),
       discoverable: pairingPayload?.relayAgent?.discoverable ?? null,
       contactable: pairingPayload?.relayAgent?.contactable ?? null,
-      online: pairingPayload?.relayAgent?.online ?? null,
-      resolved: pairingPayload?.relayAgent?.resolved ?? null,
-      bindingStatus: pairingPayload?.status === 'paired' ? 'bound' : 'unactivated',
+      online: relayOnline,
+      resolved: relayResolved,
+      bindingStatus,
     },
     profile: projectToolAccountProfile(identityPayload),
     ...projectToolAccountIdentityFields(identityPayload),

package/src/openclaw/plugin/register.js

@@ -143,6 +143,33 @@ const CHAT_INBOX_FILTER_STATUSES = Object.freeze([
   'kickoff_failed',
   'ended',
 ]);
+const CHAT_INBOX_FILTER_KEYS = Object.freeze([
+  'direction',
+  'mode',
+  'status',
+  'worldId',
+  'chatRequestId',
+  'conversationKey',
+  'localSessionKey',
+  'counterpartyAgentId',
+]);
+const CHAT_INBOX_FILTER_KEY_SET = new Set(CHAT_INBOX_FILTER_KEYS);
+const MANAGE_CONVERSATION_REQUEST_ONLY_QUERY_FIELDS = Object.freeze([
+  'displayName',
+  'agentCode',
+  'openingMessage',
+]);
+const MANAGE_CONVERSATION_FILTER_ONLY_TOP_LEVEL_FIELDS = Object.freeze([
+  'mode',
+  'status',
+  'worldId',
+  'counterpartyAgentId',
+]);
+const MANAGE_CONVERSATION_GET_STATE_TARGET_FIELDS = Object.freeze([
+  'chatRequestId',
+  'conversationKey',
+  'localSessionKey',
+]);
 
 const TERMINAL_ACCOUNT_ACTIONS = Object.freeze([
   'view_account',
@@ -293,6 +320,117 @@ function normalizeChatInboxListFiltersInput(params = {}) {
   );
 }
 
+function hasProvidedToolParam(params = {}, fieldId) {
+  if (!params || typeof params !== 'object') return false;
+  if (!Object.prototype.hasOwnProperty.call(params, fieldId)) return false;
+  const value = params[fieldId];
+  if (typeof value === 'string') return normalizeText(value, null) != null;
+  return value != null;
+}
+
+function buildChatInboxFiltersParam({ description, worldIdProperty } = {}) {
+  return objectParam({
+    description,
+    additionalProperties: false,
+    properties: {
+      direction: stringParam({
+        description: 'Filter from the current account perspective.',
+        enumValues: CHAT_INBOX_FILTER_DIRECTIONS,
+        examples: ['outbound'],
+      }),
+      mode: stringParam({
+        description: 'Filter to direct or world-scoped chat items.',
+        enumValues: CHAT_INBOX_FILTER_MODES,
+        examples: ['world'],
+      }),
+      status: stringParam({
+        description: 'Filter to pending or terminal requests, or to chats by current status.',
+        enumValues: CHAT_INBOX_FILTER_STATUSES,
+        examples: ['active'],
+      }),
+      worldId: worldIdProperty,
+      chatRequestId: stringParam({
+        description: 'Filter to one canonical chat request id.',
+        minLength: 1,
+        examples: ['req_demo_1'],
+      }),
+      conversationKey: stringParam({
+        description: 'Filter to one canonical conversation key.',
+        minLength: 1,
+        examples: ['pair:agt_alice::agt_moza:world:dating-demo-world'],
+      }),
+      localSessionKey: stringParam({
+        description: 'Filter to one local Claworld session reference for internal tracking, summaries, or orchestration only. Not a transport address for sending a user message to the peer.',
+        minLength: 1,
+        examples: ['conversation:pair:agt_alice::agt_moza:world:dating-demo-world'],
+      }),
+      counterpartyAgentId: stringParam({
+        description: 'Filter to one counterparty agentId.',
+        minLength: 1,
+        examples: ['agt_alice'],
+      }),
+    },
+  });
+}
+
+function validateChatInboxFilterInput(filters = {}, action) {
+  const source = normalizeObject(filters, {}) || {};
+  for (const key of Object.keys(source)) {
+    if (CHAT_INBOX_FILTER_KEY_SET.has(key)) continue;
+    requireManageWorldField(`filters.${key}`, `filters.${key} is not supported for action=${action}`);
+  }
+  return source;
+}
+
+function normalizeManageConversationInboxQuery(params = {}, action) {
+  const normalizedAction = normalizeTerminalConversationAction(action, 'list_related');
+  const filters = validateChatInboxFilterInput(params.filters, normalizedAction);
+
+  const requestOnlyField = MANAGE_CONVERSATION_REQUEST_ONLY_QUERY_FIELDS.find((fieldId) => hasProvidedToolParam(params, fieldId));
+  if (requestOnlyField) {
+    requireManageWorldField(requestOnlyField, `${requestOnlyField} is only supported for action=request`);
+  }
+  if (hasProvidedToolParam(params, 'limit')) {
+    requireManageWorldField('limit', `limit is not supported for action=${normalizedAction}`);
+  }
+
+  const filterOnlyField = MANAGE_CONVERSATION_FILTER_ONLY_TOP_LEVEL_FIELDS.find((fieldId) => hasProvidedToolParam(params, fieldId));
+  if (filterOnlyField) {
+    requireManageWorldField(
+      filterOnlyField,
+      `${filterOnlyField} must be passed as filters.${filterOnlyField} for action=${normalizedAction}`,
+    );
+  }
+
+  if (normalizedAction !== 'get_state') {
+    const getStateOnlyField = MANAGE_CONVERSATION_GET_STATE_TARGET_FIELDS.find((fieldId) => hasProvidedToolParam(params, fieldId));
+    if (getStateOnlyField) {
+      requireManageWorldField(
+        getStateOnlyField,
+        `${getStateOnlyField} must be passed as filters.${getStateOnlyField} for action=${normalizedAction}`,
+      );
+    }
+  }
+
+  const mergedFilters = {
+    ...filters,
+    ...(!Object.prototype.hasOwnProperty.call(filters, 'direction') && hasProvidedToolParam(params, 'direction')
+      ? { direction: params.direction }
+      : {}),
+    ...(normalizedAction === 'get_state'
+      ? Object.fromEntries(
+          MANAGE_CONVERSATION_GET_STATE_TARGET_FIELDS
+            .filter((fieldId) => (
+              !Object.prototype.hasOwnProperty.call(filters, fieldId)
+              && hasProvidedToolParam(params, fieldId)
+            ))
+            .map((fieldId) => [fieldId, params[fieldId]]),
+        )
+      : {}),
+  };
+  return normalizeChatInboxListFiltersInput({ filters: mergedFilters });
+}
+
 function parseToolResultPayload(result = null) {
   const text = result?.content?.[0]?.text;
   if (typeof text !== 'string') return null;
@@ -925,10 +1063,27 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
           agentCode: stringParam({ description: 'Target public agent code for request.', minLength: 1 }),
           openingMessage: stringParam({ description: 'Request/re-engagement kickoff message.', minLength: 1 }),
           worldId: worldIdProperty,
-          filters: objectParam({ description: 'List filters.', additionalProperties: true }),
-          chatRequestId: stringParam({ description: 'Request id for accept/reject.', minLength: 1 }),
-          conversationKey: stringParam({ description: 'Conversation key for get_state/close.', minLength: 1 }),
-          localSessionKey: stringParam({ description: 'Local conversation session key for get_state/close.', minLength: 1 }),
+          direction: stringParam({
+            description: 'Top-level alias for filters.direction on action=list_related/get_state.',
+            enumValues: CHAT_INBOX_FILTER_DIRECTIONS,
+            examples: ['outbound'],
+          }),
+          filters: buildChatInboxFiltersParam({
+            description: 'Inbox filters for action=list_related/get_state.',
+            worldIdProperty,
+          }),
+          chatRequestId: stringParam({
+            description: 'Request id for action=accept/reject, or a top-level get_state convenience target that normalizes to filters.chatRequestId.',
+            minLength: 1,
+          }),
+          conversationKey: stringParam({
+            description: 'Conversation key for action=close, or a top-level get_state convenience target that normalizes to filters.conversationKey.',
+            minLength: 1,
+          }),
+          localSessionKey: stringParam({
+            description: 'Local conversation session key for action=close, or a top-level get_state convenience target that normalizes to filters.localSessionKey.',
+            minLength: 1,
+          }),
         },
       }),
       async execute(toolCallId, params = {}) {
@@ -940,10 +1095,19 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
           });
           return rewriteToolResultName(result, manageConversationsTool, action);
         }
-        if (['list_related', 'get_state', 'accept', 'reject'].includes(action)) {
+        if (action === 'list_related' || action === 'get_state') {
+          const filters = normalizeManageConversationInboxQuery(params, action);
+          const result = await requireTerminalTool(internalTools, 'claworld_chat_inbox').execute(toolCallId, {
+            ...params,
+            action: 'list',
+            ...(Object.keys(filters).length > 0 ? { filters } : {}),
+          });
+          return rewriteToolResultName(result, manageConversationsTool, action);
+        }
+        if (action === 'accept' || action === 'reject') {
           const result = await requireTerminalTool(internalTools, 'claworld_chat_inbox').execute(toolCallId, {
             ...params,
-            action: ['list_related', 'get_state'].includes(action) ? 'list' : action,
+            action,
           });
           return rewriteToolResultName(result, manageConversationsTool, action);
         }
@@ -1691,45 +1855,10 @@ function buildRegisteredTools(api, plugin) {
             examples: ['list', 'accept', 'reject'],
           }),
           filters: objectParam({
-            description: 'Optional list filters for query mode. Omit to review the full inbox across inbound and outbound items.',
-            properties: {
-              direction: stringParam({
-                description: 'Filter from the current account perspective.',
-                enumValues: CHAT_INBOX_FILTER_DIRECTIONS,
-                examples: ['outbound'],
-              }),
-              mode: stringParam({
-                description: 'Filter to direct or world-scoped chat items.',
-                enumValues: CHAT_INBOX_FILTER_MODES,
-                examples: ['world'],
-              }),
-              status: stringParam({
-                description: 'Filter to pending or terminal requests, or to chats by current status.',
-                enumValues: CHAT_INBOX_FILTER_STATUSES,
-                examples: ['active'],
-              }),
-              worldId: worldIdProperty,
-              chatRequestId: stringParam({
-                description: 'Filter to one canonical chat request id.',
-                minLength: 1,
-                examples: ['req_demo_1'],
-              }),
-              conversationKey: stringParam({
-                description: 'Filter to one canonical conversation key.',
-                minLength: 1,
-                examples: ['pair:agt_alice::agt_moza:world:dating-demo-world'],
-              }),
-              localSessionKey: stringParam({
-                description: 'Filter to one local Claworld session reference for internal tracking, summaries, or orchestration only. Not a transport address for sending a user message to the peer.',
-                minLength: 1,
-                examples: ['conversation:pair:agt_alice::agt_moza:world:dating-demo-world'],
-              }),
-              counterpartyAgentId: stringParam({
-                description: 'Filter to one counterparty agentId.',
-                minLength: 1,
-                examples: ['agt_alice'],
-              }),
-            },
+            ...buildChatInboxFiltersParam({
+              description: 'Optional list filters for query mode. Omit to review the full inbox across inbound and outbound items.',
+              worldIdProperty,
+            }),
           }),
           chatRequestId: stringParam({
             description: 'Canonical chat request id returned by claworld_chat_inbox pendingRequests. Required for action=accept or action=reject.',
@@ -1969,7 +2098,16 @@ function buildRegisteredTools(api, plugin) {
           expiresInSeconds: params.expiresInSeconds ?? null,
         });
         const pairedAgentId = identityPayload?.agentId || runtimeConfig.relay?.agentId || null;
-        const relayAgent = pairedAgentId
+        const pairedRuntimeConfig = pairedAgentId
+          ? {
+            ...runtimeConfig,
+            relay: {
+              ...(runtimeConfig.relay && typeof runtimeConfig.relay === 'object' ? runtimeConfig.relay : {}),
+              agentId: pairedAgentId,
+            },
+          }
+          : runtimeConfig;
+        const relayAgentFallback = pairedAgentId
           ? {
             agentId: pairedAgentId,
             displayName: normalizeText(
@@ -1990,23 +2128,39 @@ function buildRegisteredTools(api, plugin) {
           || runtimeConfig.relay?.appToken
           || runtimeConfig.relay?.credentialToken,
         );
+        const activationReady = hasConfiguredAppToken;
+        const bindingReady = activationReady && Boolean(pairedAgentId);
+        const bindingStatus = activationReady
+          ? (bindingReady ? 'bound' : 'identity_unresolved')
+          : 'unactivated';
+        let relayAgent = relayAgentFallback;
+        if (hasConfiguredAppToken && pairedAgentId && typeof plugin.helpers?.pairing?.resolveAgentIdentity === 'function') {
+          const resolvedRelayAgent = await plugin.helpers.pairing.resolveAgentIdentity({
+            cfg,
+            accountId,
+            runtimeConfig: pairedRuntimeConfig,
+            agentId: pairedAgentId,
+          });
+          if (resolvedRelayAgent && typeof resolvedRelayAgent === 'object') {
+            relayAgent = {
+              ...relayAgentFallback,
+              ...resolvedRelayAgent,
+              agentId: normalizeText(resolvedRelayAgent.agentId, pairedAgentId),
+              displayName: normalizeText(resolvedRelayAgent.displayName, relayAgentFallback?.displayName ?? null),
+            };
+          }
+        }
         const pairingPayload = {
-          status: hasConfiguredAppToken ? 'paired' : 'unpaired',
-          reason: hasConfiguredAppToken
+          status: activationReady ? 'paired' : 'unpaired',
+          bindingReady,
+          bindingStatus,
+          reason: activationReady
             ? (pairedAgentId ? null : 'missing_agent_id')
             : 'missing_app_token',
-          bindingSource: hasConfiguredAppToken
+          bindingSource: activationReady
             ? 'configured_app_token'
             : (runtimeConfig.registration?.enabled === true ? 'registration_pending' : 'unbound'),
-          runtimeConfig: pairedAgentId
-            ? {
-              ...runtimeConfig,
-              relay: {
-                ...(runtimeConfig.relay && typeof runtimeConfig.relay === 'object' ? runtimeConfig.relay : {}),
-                agentId: pairedAgentId,
-              },
-            }
-            : runtimeConfig,
+          runtimeConfig: pairedRuntimeConfig,
           relayAgent,
         };
         return buildToolResult(projectToolAccountViewResponse({

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

@@ -5,6 +5,51 @@ export const STALE_CONNECTION_CLOSE_CODE = 4002;
 export const TERMINAL_CLOSE_REASONS = new Set(['duplicate_connection_replaced', 'stale_connection']);
 export const DEFAULT_REPLY_ACK_TIMEOUT_MS = 5000;
 
+function cloneObject(value, fallback = {}) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return { ...fallback };
+  return { ...value };
+}
+
+function normalizeEnvelopeText(value, fallback = null) {
+  if (value == null) return fallback;
+  const normalized = String(value).trim();
+  return normalized || fallback;
+}
+
+function resolveEnvelopeMessageId(data = {}, payload = {}) {
+  const notification = payload.notification && typeof payload.notification === 'object' && !Array.isArray(payload.notification)
+    ? payload.notification
+    : data.notification && typeof data.notification === 'object' && !Array.isArray(data.notification)
+      ? data.notification
+      : {};
+  const metadata = data.metadata && typeof data.metadata === 'object' && !Array.isArray(data.metadata)
+    ? data.metadata
+    : payload.metadata && typeof payload.metadata === 'object' && !Array.isArray(payload.metadata)
+      ? payload.metadata
+      : {};
+  const candidates = [
+    data.deliveryId,
+    data.inboxItemId,
+    data.messageId,
+    data.eventId,
+    data.notificationId,
+    payload.deliveryId,
+    payload.inboxItemId,
+    payload.messageId,
+    payload.eventId,
+    payload.notificationId,
+    metadata.messageId,
+    metadata.eventId,
+    metadata.notificationId,
+    notification.notificationId,
+  ];
+  for (const candidate of candidates) {
+    const normalized = normalizeEnvelopeText(candidate, null);
+    if (normalized) return normalized;
+  }
+  return null;
+}
+
 export function normalizeRelayWebSocketUrl(serverUrl) {
   const parsed = new URL(serverUrl);
   if (parsed.protocol === 'http:') parsed.protocol = 'ws:';
@@ -23,63 +68,99 @@ export function normalizeRelayWebSocketUrl(serverUrl) {
 
 export function buildInboundEnvelope(message = {}) {
   const data = message.data || {};
+  const directPayload = data.payload && typeof data.payload === 'object' && !Array.isArray(data.payload)
+    ? { ...data.payload }
+    : {};
   const metadata = data.metadata && typeof data.metadata === 'object' && !Array.isArray(data.metadata)
     ? { ...data.metadata }
-    : {};
-  if (message.event !== 'delivery') {
-    const eventType = normalizeOptionalText(data.eventType) || normalizeOptionalText(message.event);
-    const notification = data.notification && typeof data.notification === 'object' && !Array.isArray(data.notification)
+    : directPayload.metadata && typeof directPayload.metadata === 'object' && !Array.isArray(directPayload.metadata)
+      ? { ...directPayload.metadata }
+      : cloneObject(data.meta, {});
+  const payloadEventType = normalizeEnvelopeText(directPayload.eventType, null);
+  const dataEventType = normalizeEnvelopeText(data.eventType, null);
+  const eventType = dataEventType
+    || payloadEventType
+    || (message.event === 'delivery' ? 'delivery' : normalizeEnvelopeText(message.event, null));
+  const payload = Object.keys(directPayload).length > 0
+    ? { ...directPayload }
+    : cloneObject(data, {});
+  if (Object.keys(directPayload).length > 0) {
+    for (const key of [
+      'eventType',
+      'eventName',
+      'sessionKind',
+      'sessionKey',
+      'targetSessionKey',
+      'targetAgentId',
+      'text',
+      'body',
+      'notification',
+      'conversationKey',
+      'worldId',
+    ]) {
+      if (payload[key] == null && data[key] != null) payload[key] = data[key];
+    }
+  }
+  const notification = payload.notification && typeof payload.notification === 'object' && !Array.isArray(payload.notification)
+    ? payload.notification
+    : data.notification && typeof data.notification === 'object' && !Array.isArray(data.notification)
       ? data.notification
       : {};
-    const targetAgentId = normalizeOptionalText(
-      data.targetAgentId
-      || notification.targetAgentId
-      || metadata.targetAgentId,
-    );
-    const sessionKey = normalizeOptionalText(
-      data.sessionKey
-      || notification.targetSessionKey
-      || metadata.sessionKey,
-    ) || (targetAgentId ? `management:${targetAgentId}` : null);
-    if (!eventType || !sessionKey) return null;
-    return {
-      eventType,
-      eventName: normalizeOptionalText(data.eventName) || normalizeOptionalText(message.event),
-      eventId: normalizeOptionalText(data.eventId)
-        || normalizeOptionalText(data.inboxItemId)
-        || normalizeOptionalText(notification.notificationId)
-        || null,
-      sessionKey,
-      targetAgentId,
-      conversationKey: normalizeOptionalText(data.conversationKey)
-        || normalizeOptionalText(notification.relatedObjects?.conversationKey)
-        || null,
-      worldId: normalizeOptionalText(data.worldId)
-        || normalizeOptionalText(notification.relatedObjects?.worldId)
-        || null,
-      createdAt: data.createdAt || notification.createdAt || null,
-      updatedAt: data.updatedAt || notification.updatedAt || null,
-      payload: data && typeof data === 'object' && !Array.isArray(data)
-        ? { ...data }
-        : {},
-      metadata: {
-        ...metadata,
-        relayEvent: normalizeOptionalText(message.event),
-        inboxItemId: normalizeOptionalText(data.inboxItemId) || null,
-      },
-    };
-  }
+  const targetAgentId = normalizeEnvelopeText(
+    data.targetAgentId,
+    normalizeEnvelopeText(
+      payload.targetAgentId,
+      normalizeEnvelopeText(notification.targetAgentId, normalizeEnvelopeText(metadata.targetAgentId, null)),
+    ),
+  );
+  const sessionKey = normalizeEnvelopeText(
+    data.sessionKey,
+    normalizeEnvelopeText(
+      payload.sessionKey,
+      normalizeEnvelopeText(
+        data.targetSessionKey,
+        normalizeEnvelopeText(
+          payload.targetSessionKey,
+          normalizeEnvelopeText(
+            notification.targetSessionKey,
+            normalizeEnvelopeText(metadata.sessionKey, targetAgentId ? `management:${targetAgentId}` : null),
+          ),
+        ),
+      ),
+    ),
+  );
+  const isDeliveryEvent = message.event === 'delivery';
+  const isRoutableEvent = Boolean(eventType && sessionKey);
+  if (!isDeliveryEvent && !isRoutableEvent) return null;
+  const deliveryId = resolveEnvelopeMessageId(data, payload);
+  const eventName = normalizeEnvelopeText(
+    data.eventName,
+    normalizeEnvelopeText(payload.eventName, isDeliveryEvent ? null : normalizeEnvelopeText(message.event, null)),
+  );
   return {
-    eventType: data.eventType || 'delivery',
-    deliveryId: data.deliveryId || null,
-    sessionKey: data.sessionKey || null,
-    createdAt: data.createdAt || null,
-    updatedAt: data.updatedAt || null,
+    eventType: eventType || 'delivery',
+    eventName,
+    eventId: deliveryId,
+    deliveryId,
+    sessionKey,
+    targetAgentId,
+    conversationKey: normalizeEnvelopeText(
+      data.conversationKey,
+      normalizeEnvelopeText(payload.conversationKey, normalizeEnvelopeText(notification.relatedObjects?.conversationKey, null)),
+    ),
+    worldId: normalizeEnvelopeText(
+      data.worldId,
+      normalizeEnvelopeText(payload.worldId, normalizeEnvelopeText(notification.relatedObjects?.worldId, null)),
+    ),
+    createdAt: data.createdAt || payload.createdAt || data.availableAt || payload.availableAt || notification.createdAt || null,
+    updatedAt: data.updatedAt || payload.updatedAt || notification.updatedAt || null,
     turnCreatedAt: data.turnCreatedAt || null,
-    payload: data.payload && typeof data.payload === 'object' && !Array.isArray(data.payload)
-      ? { ...data.payload }
-      : {},
-    metadata,
+    payload,
+    metadata: {
+      ...metadata,
+      relayEvent: normalizeEnvelopeText(message.event, null),
+      inboxItemId: normalizeEnvelopeText(data.inboxItemId, normalizeEnvelopeText(payload.inboxItemId, null)),
+    },
   };
 }