@xfxstudio/claworld 0.2.14 → 0.2.16

package/src/openclaw/plugin/claworld-channel-plugin.js

@@ -1,3 +1,5 @@
+import { randomUUID } from 'node:crypto';
+
 import {
   applyRuntimeIdentity,
   buildRuntimeAuthHeaders,
@@ -74,6 +76,10 @@ function requireClientMessageId(value = null) {
   return normalized;
 }
 
+function buildGeneratedClientMessageId() {
+  return `openclaw_manual_${randomUUID()}`;
+}
+
 function buildRelayAgentSummary(item = {}) {
   const normalizedAgentId = normalizeClaworldText(item?.agentId, null);
   return {
@@ -338,9 +344,9 @@ async function deliverRelayMessage({ runtimeConfig, to, text, fetchImpl, logger,
   }
   payload.source = normalizeClaworldText(payload.source, 'openclaw-claworld');
   payload.accountId = normalizeClaworldText(payload.accountId, runtimeConfig.accountId);
-  const clientMessageId = requireClientMessageId(
+  const clientMessageId = normalizePluginOptionalText(
     outboundContext.clientMessageId || outboundContext.metadata?.clientMessageId || null
-  );
+  ) || buildGeneratedClientMessageId();
 
   const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
   const result = await fetchJson(fetchImpl, `${baseUrl}/v1/messages`, {
@@ -436,22 +442,24 @@ function createRelayRouteError({
 async function createChatRequest({
   runtimeConfig,
   fromAgentId,
-  targetAgentId,
+  displayName = null,
+  agentCode = null,
   openingMessage = null,
   worldId = null,
   requestContext = null,
   fetchImpl,
 }) {
-  const normalizedTargetAgentId = normalizeClaworldText(targetAgentId, null);
-  if (!normalizedTargetAgentId) {
+  const normalizedDisplayName = normalizeClaworldText(displayName, null);
+  const normalizedAgentCode = normalizeClaworldText(agentCode, null)?.toUpperCase() || null;
+  if (!normalizedDisplayName || !normalizedAgentCode) {
     throw createRuntimeBoundaryError({
       code: 'tool_input_invalid',
       category: 'input',
       status: 400,
-      message: 'claworld chat request target requires targetAgentId',
-      publicMessage: 'claworld chat request target requires targetAgentId',
+      message: 'claworld chat request target requires displayName and agentCode',
+      publicMessage: 'claworld chat request target requires displayName and agentCode',
       recoverable: true,
-      context: { field: 'targetAgentId' },
+      context: { fields: ['displayName', 'agentCode'] },
     });
   }
   const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
@@ -464,7 +472,8 @@ async function createChatRequest({
     },
     body: JSON.stringify({
       fromAgentId,
-      targetAgentId: normalizedTargetAgentId,
+      displayName: normalizedDisplayName,
+      agentCode: normalizedAgentCode,
       openingMessage: normalizeClaworldText(openingMessage, null),
       ...(normalizeClaworldText(worldId, null) ? { worldId: normalizeClaworldText(worldId, null) } : {}),
       ...(requestContext && typeof requestContext === 'object' && !Array.isArray(requestContext)
@@ -478,7 +487,11 @@ async function createChatRequest({
       runtimeConfig,
       code: 'chat_request_create_failed',
       publicMessage: 'failed to create chat request',
-      context: { fromAgentId, targetAgentId: normalizedTargetAgentId },
+      context: {
+        fromAgentId,
+        displayName: normalizedDisplayName,
+        agentCode: normalizedAgentCode,
+      },
     });
   }
   return result.body || {};
@@ -570,62 +583,6 @@ async function rejectChatRequest({
   return result.body || {};
 }
 
-async function syncChatRequestApprovalPolicy({
-  runtimeConfig,
-  fetchImpl,
-  logger,
-}) {
-  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
-  let result;
-  try {
-    result = await fetchJson(fetchImpl, `${baseUrl}/v1/chat-requests/approval-policy`, {
-      method: 'PUT',
-      headers: {
-        'content-type': 'application/json',
-        ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
-        ...buildRuntimeAuthHeaders(runtimeConfig),
-      },
-      body: JSON.stringify({
-        accountId: runtimeConfig.accountId || null,
-        approval: runtimeConfig.approval || {},
-      }),
-    });
-  } catch (error) {
-    logger.warn?.(`[claworld:${runtimeConfig.accountId || 'default'}] approval policy sync failed`, {
-      error: error?.message || String(error),
-      code: error?.code || null,
-      category: error?.category || null,
-    });
-    return {
-      ok: false,
-      status: error?.status || null,
-      body: null,
-      error,
-    };
-  }
-  if (!result.ok) {
-    logger.warn?.(`[claworld:${runtimeConfig.accountId || 'default'}] approval policy sync failed`, {
-      status: result.status,
-      body: result.body,
-    });
-    return {
-      ok: false,
-      status: result.status,
-      body: result.body,
-    };
-  }
-
-  logger.info?.(`[claworld:${runtimeConfig.accountId || 'default'}] approval policy sync ok`, {
-    mode: result.body?.approvalPolicy?.policy?.mode || runtimeConfig.approval?.mode || null,
-    syncedAt: result.body?.approvalPolicy?.syncedAt || null,
-  });
-  return {
-    ok: true,
-    status: result.status,
-    body: result.body,
-  };
-}
-
 function waitForAbort(signal) {
   return new Promise((resolve) => {
     if (!signal) return resolve({ reason: 'missing_abort_signal' });
@@ -828,6 +785,7 @@ async function fetchPublicIdentity({
         totalLikesGiven: 0,
         totalDislikesGiven: 0,
       },
+      profile: null,
     };
   }
 
@@ -840,6 +798,7 @@ async function fetchPublicIdentity({
       ...buildRuntimeAuthHeaders(runtimeConfig),
     },
     body: JSON.stringify({
+      accountId: runtimeConfig.accountId || null,
       ...(agentId ? { agentId } : {}),
       action: 'view',
       ...(generateShareCard === true ? { generateShareCard: true } : {}),
@@ -934,6 +893,7 @@ async function updatePublicIdentity({
       ...buildRuntimeAuthHeaders(resolvedRuntimeConfig),
     },
     body: JSON.stringify({
+      accountId: resolvedRuntimeConfig.accountId || null,
       ...(resolvedAgentId ? { agentId: resolvedAgentId } : {}),
       action: 'update_identity',
       displayName: normalizedDisplayName,
@@ -966,6 +926,100 @@ async function updatePublicIdentity({
   };
 }
 
+async function updateChatRequestApprovalPolicy({
+  runtimeConfig,
+  agentId = null,
+  chatRequestApprovalPolicy = null,
+  fetchImpl,
+}) {
+  if (!resolveRuntimeAppToken(runtimeConfig)) {
+    throw createRuntimeBoundaryError({
+      code: 'claworld_account_unactivated',
+      category: 'conflict',
+      status: 409,
+      message: 'claworld account must be activated before updating chat policy',
+      publicMessage: 'activate the Claworld account before changing chat policy',
+      recoverable: true,
+    });
+  }
+
+  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/profile`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
+      ...buildRuntimeAuthHeaders(runtimeConfig),
+    },
+    body: JSON.stringify({
+      accountId: runtimeConfig.accountId || null,
+      ...(agentId ? { agentId } : {}),
+      action: 'update_chat_policy',
+      chatRequestApprovalPolicy,
+    }),
+  });
+  if (!result.ok) {
+    createRelayRouteError({
+      result,
+      runtimeConfig,
+      code: 'chat_request_approval_policy_update_failed',
+      publicMessage: 'failed to update chat policy',
+      context: {
+        accountId: runtimeConfig.accountId || null,
+        agentId: normalizeClaworldText(agentId, null),
+      },
+    });
+  }
+  return result.body || {};
+}
+
+async function updateGlobalProfile({
+  runtimeConfig,
+  agentId = null,
+  profile = '',
+  fetchImpl,
+}) {
+  if (!resolveRuntimeAppToken(runtimeConfig)) {
+    throw createRuntimeBoundaryError({
+      code: 'claworld_account_unactivated',
+      category: 'conflict',
+      status: 409,
+      message: 'claworld account must be activated before updating profile',
+      publicMessage: 'activate the Claworld account before updating profile',
+      recoverable: true,
+    });
+  }
+
+  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/profile`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
+      ...buildRuntimeAuthHeaders(runtimeConfig),
+    },
+    body: JSON.stringify({
+      accountId: runtimeConfig.accountId || null,
+      ...(agentId ? { agentId } : {}),
+      action: 'update_profile',
+      profile,
+    }),
+  });
+  if (!result.ok) {
+    createRelayRouteError({
+      result,
+      runtimeConfig,
+      code: 'profile_update_failed',
+      publicMessage: 'failed to update profile',
+      context: {
+        accountId: runtimeConfig.accountId || null,
+        agentId: normalizeClaworldText(agentId, null),
+      },
+    });
+  }
+  return result.body || {};
+}
+
 async function renderAgentCard({
   runtimeConfig,
   agentId = null,
@@ -1020,78 +1074,6 @@ async function renderAgentCard({
   return result.body || {};
 }
 
-async function registerRelayBinding({ runtimeConfig, fetchImpl, logger }) {
-  if (typeof fetchImpl !== 'function') {
-    throw new Error('fetch is unavailable for relay registration');
-  }
-
-  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
-  const registration = normalizeRuntimeRegistration(runtimeConfig);
-  const registerResult = await fetchJson(fetchImpl, `${baseUrl}/v1/agents/register`, {
-    method: 'POST',
-    headers: buildRuntimeAuthHeaders(runtimeConfig, {
-      accept: 'application/json',
-      'content-type': 'application/json',
-      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
-    }),
-    body: JSON.stringify({
-      ...(registration.displayName ? { displayName: registration.displayName } : {}),
-    }),
-  });
-
-  if (!registerResult.ok) {
-    logger.error?.('[claworld:bootstrap] register relay agent failed', {
-      accountId: runtimeConfig.accountId,
-      status: registerResult.status,
-      body: registerResult.body,
-    });
-
-    const errorCode = normalizeClaworldText(registerResult.body?.error, 'relay_agent_registration_failed');
-    const category = registerResult.status === 401
-      ? 'auth'
-      : registerResult.status === 403
-        ? 'policy'
-        : registerResult.status === 409
-          ? 'conflict'
-          : registerResult.status >= 500
-            ? 'transport'
-            : 'config';
-    const publicMessage = 'relay registration failed';
-
-    throw createRuntimeBoundaryError({
-      code: errorCode,
-      category,
-      status: registerResult.status,
-      message: `failed to register relay agent: ${registerResult.status}`,
-      publicMessage,
-      recoverable: registerResult.status >= 500,
-      context: {
-        accountId: runtimeConfig.accountId || null,
-        conflictingAgentId: normalizeClaworldText(registerResult.body?.agent?.agentId, null),
-        appTokenConfigured: Boolean(resolveRuntimeAppToken(runtimeConfig)),
-      },
-    });
-  }
-
-  const registeredAgent = registerResult.body?.agent || null;
-  const appToken = normalizeClaworldText(registerResult.body?.appToken, resolveRuntimeAppToken(runtimeConfig));
-  if (!registeredAgent?.agentId || !appToken) {
-    throw new Error('relay registration did not produce relay agent binding');
-  }
-
-  return {
-    bindingSource: normalizeClaworldText(
-      registerResult.body?.bindingSource,
-      resolveRuntimeAppToken(runtimeConfig) ? 'provided_app_token' : 'created_agent_app_token',
-    ),
-    runtimeConfig: applyRuntimeIdentity(runtimeConfig, {
-      agentId: registeredAgent.agentId,
-      appToken,
-    }),
-    relayAgent: buildRelayAgentSummary(registeredAgent, runtimeConfig),
-  };
-}
-
 async function fetchRelayAgents({ runtimeConfig, fetchImpl, logger }) {
   if (typeof fetchImpl !== 'function') {
     throw new Error('fetch is unavailable for relay agent lookup');
@@ -1155,40 +1137,6 @@ async function resolveRelayAgentSummary({
   };
 }
 
-async function ensureAgentPairing({ runtimeConfig, fetchImpl, logger }) {
-  const binding = await ensureRelayBinding({ runtimeConfig, fetchImpl, logger });
-  const pairedRuntimeConfig = binding.runtimeConfig;
-  const relayAgentId = normalizeClaworldText(pairedRuntimeConfig.relay?.agentId, null);
-
-  if (!relayAgentId) {
-    return {
-      status: 'unpaired',
-      reason: 'missing_app_token_or_registration',
-      bindingSource: binding.bindingSource,
-      runtimeConfig: pairedRuntimeConfig,
-      relayAgent: await resolveRelayAgentSummary({
-        runtimeConfig: pairedRuntimeConfig,
-        fetchImpl,
-        logger,
-        agentId: relayAgentId,
-      }),
-    };
-  }
-
-  return {
-    status: 'paired',
-    reason: null,
-    bindingSource: binding.bindingSource,
-    runtimeConfig: pairedRuntimeConfig,
-      relayAgent: await resolveRelayAgentSummary({
-        runtimeConfig: pairedRuntimeConfig,
-        fetchImpl,
-        logger,
-        agentId: relayAgentId,
-      }),
-    };
-}
-
 async function fetchPostSetupWorldDirectory({ cfg, accountId, runtimeConfig, limit = null, sort = null, page = null, fetchImpl, logger }) {
   if (typeof fetchImpl !== 'function') {
     throw new Error('fetch is unavailable for claworld product-shell helper');
@@ -1234,24 +1182,32 @@ async function ensureRelayBinding({ runtimeConfig, fetchImpl, logger }) {
     };
   }
 
-  if (!appToken && !registration.enabled) {
-    return { runtimeConfig: normalizedRuntimeConfig, bindingSource: 'no_registration_context' };
+  if (appToken) {
+    const identityPayload = await fetchPublicIdentity({
+      runtimeConfig: normalizedRuntimeConfig,
+      agentId: null,
+      generateShareCard: false,
+      expiresInSeconds: null,
+      fetchImpl,
+    });
+    const resolvedAgentId = normalizeClaworldText(identityPayload?.agentId, null);
+    if (resolvedAgentId) {
+      return {
+        runtimeConfig: applyRuntimeIdentity(normalizedRuntimeConfig, { agentId: resolvedAgentId }),
+        bindingSource: 'configured_app_token',
+      };
+    }
+    logger.info?.('[claworld:bootstrap] configured credential is missing relay.agentId; waiting for a later authenticated account read or update');
+    return {
+      runtimeConfig: normalizedRuntimeConfig,
+      bindingSource: 'configured_app_token',
+    };
   }
 
-  logger.info?.('[claworld:bootstrap] ensureRelayBinding start', {
-    accountId: normalizedRuntimeConfig.accountId,
-    serverUrl: normalizedRuntimeConfig.serverUrl,
-    appTokenConfigured: Boolean(appToken),
-    registrationEnabled: registration.enabled,
-    displayName: registration.displayName || null,
-    hasRelayAgentId: Boolean(normalizedRuntimeConfig.relay?.agentId),
-  });
-
-  return await registerRelayBinding({
+  return {
     runtimeConfig: normalizedRuntimeConfig,
-    fetchImpl,
-    logger,
-  });
+    bindingSource: registration.enabled ? 'registration_pending' : 'unbound',
+  };
 }
 
 function resolveDeliveryWorldId(delivery = {}) {
@@ -2210,12 +2166,6 @@ export function createClaworldChannelPlugin({
           }
         }
 
-        await syncChatRequestApprovalPolicy({
-          runtimeConfig,
-          fetchImpl,
-          logger,
-        });
-
         accountRuntimeContexts.set(accountKey, {
           runtime: pluginRuntime,
           cfg: context.cfg || null,
@@ -2395,7 +2345,7 @@ export function createClaworldChannelPlugin({
     });
   }
 
-  async function updateRuntimePublicIdentity(context = {}) {
+async function updateRuntimePublicIdentity(context = {}) {
     const resolvedContext = resolveConfiguredRuntimeContext(context);
     const updateResult = await updatePublicIdentity({
       runtimeConfig: resolvedContext.runtimeConfig,
@@ -2414,37 +2364,56 @@ export function createClaworldChannelPlugin({
       : resolvedContext.runtimeConfig;
     const nextAgentId = normalizeClaworldText(
       runtimeActivation?.agentId,
+      normalizeClaworldText(
+        updateResult?.agentId,
+        null,
+      ),
+    ) || normalizeClaworldText(
       normalizeClaworldText(resolvedContext.agentId, normalizeClaworldText(nextRuntimeConfig?.relay?.agentId, null)),
+      null,
     );
+    const boundRuntimeConfig = nextAgentId
+      ? applyRuntimeIdentity(nextRuntimeConfig, { agentId: nextAgentId })
+      : nextRuntimeConfig;
 
-    if (runtimeActivation && resolveRuntimeAppToken(nextRuntimeConfig)) {
+    const previousAgentId = normalizeClaworldText(
+      resolvedContext.runtimeConfig?.relay?.agentId,
+      normalizeClaworldText(resolvedContext.agentId, null),
+    );
+    const shouldPersistRuntimeBinding = Boolean(
+      resolveRuntimeAppToken(nextRuntimeConfig)
+      && nextAgentId
+      && (runtimeActivation || previousAgentId !== nextAgentId),
+    );
+
+    if (shouldPersistRuntimeBinding) {
       const runtimeResolution = resolvePluginRuntimeCandidate(context.runtime || null);
       try {
         await persistRuntimeAppToken({
           runtime: runtimeResolution.runtime,
-          accountId: resolvedContext.accountId || nextRuntimeConfig.accountId || null,
-          appToken: resolveRuntimeAppToken(nextRuntimeConfig),
+          accountId: resolvedContext.accountId || boundRuntimeConfig.accountId || null,
+          appToken: resolveRuntimeAppToken(boundRuntimeConfig),
           relayAgentId: nextAgentId,
         });
       } catch (error) {
         logger.warn?.('[claworld:profile] failed to persist activated runtime binding', {
-          accountId: resolvedContext.accountId || nextRuntimeConfig.accountId || null,
+          accountId: resolvedContext.accountId || boundRuntimeConfig.accountId || null,
           error: error?.message || String(error),
         });
       }
 
       rememberAccountBinding({
-        runtimeConfig: nextRuntimeConfig,
-        accountId: resolvedContext.accountId || nextRuntimeConfig.accountId || null,
-        bindingSource: 'activated_app_token',
+        runtimeConfig: boundRuntimeConfig,
+        accountId: resolvedContext.accountId || boundRuntimeConfig.accountId || null,
+        bindingSource: runtimeActivation ? 'activated_app_token' : 'configured_app_token',
       });
 
-      const accountKey = resolveAccountBindingKey(nextRuntimeConfig, resolvedContext.accountId || null);
+      const accountKey = resolveAccountBindingKey(boundRuntimeConfig, resolvedContext.accountId || null);
       const currentRuntimeContext = accountRuntimeContexts.get(accountKey) || null;
       if (currentRuntimeContext) {
         accountRuntimeContexts.set(accountKey, {
           ...currentRuntimeContext,
-          runtimeConfig: nextRuntimeConfig,
+          runtimeConfig: boundRuntimeConfig,
           deferredFailure: null,
           deferredErrorMessage: null,
         });
@@ -2454,20 +2423,42 @@ export function createClaworldChannelPlugin({
     const payload = updateResult && typeof updateResult === 'object' && !Array.isArray(updateResult)
       ? { ...updateResult }
       : {};
-    delete payload.runtimeConfig;
-    return payload;
-  }
+  delete payload.runtimeConfig;
+  return payload;
+}
 
-  async function generateRuntimeProfileCard(context = {}) {
-    const resolvedContext = await resolveBoundRuntimeContext(context);
-    return renderAgentCard({
-      runtimeConfig: resolvedContext.runtimeConfig,
-      agentId: context.agentId || resolvedContext.agentId || null,
-      expiresInSeconds: context.expiresInSeconds ?? null,
-      forceRegenerate: context.forceRegenerate !== false,
-      fetchImpl,
-    });
-  }
+async function updateRuntimeChatRequestApprovalPolicy(context = {}) {
+  const resolvedContext = await resolveBoundRuntimeContext(context);
+  return updateChatRequestApprovalPolicy({
+    runtimeConfig: resolvedContext.runtimeConfig,
+    agentId: resolvedContext.agentId || null,
+    chatRequestApprovalPolicy: context.chatRequestApprovalPolicy || null,
+    fetchImpl,
+  });
+}
+
+async function updateRuntimeProfile(context = {}) {
+  const resolvedContext = await resolveBoundRuntimeContext(context);
+  return updateGlobalProfile({
+    runtimeConfig: resolvedContext.runtimeConfig,
+    agentId: resolvedContext.agentId || null,
+    profile: Object.prototype.hasOwnProperty.call(context, 'profile')
+      ? (context.profile == null ? '' : String(context.profile))
+      : '',
+    fetchImpl,
+  });
+}
+
+async function generateRuntimeProfileCard(context = {}) {
+  const resolvedContext = await resolveBoundRuntimeContext(context);
+  return renderAgentCard({
+    runtimeConfig: resolvedContext.runtimeConfig,
+    agentId: context.agentId || resolvedContext.agentId || null,
+    expiresInSeconds: context.expiresInSeconds ?? null,
+    forceRegenerate: context.forceRegenerate !== false,
+    fetchImpl,
+  });
+}
 
   return {
     id: 'claworld',
@@ -2496,7 +2487,7 @@ export function createClaworldChannelPlugin({
       messageToolHints: () => [
         '- Claworld message targets are canonical `agentId` values such as `agt_xxx`.',
         '- Omit `target` to keep replying inside the current A2A session when the runtime already inferred the peer.',
-        '- Resolve public identity like `displayName#code` to `agentId` before opening a new relay session to another agent.',
+        '- For new chat requests, use the target `displayName` plus public `agentCode`; the backend resolves by `agentCode` and returns a warning if the displayName is stale.',
       ],
     },
     reload: { configPrefixes: ['channels.claworld'] },
@@ -2612,11 +2603,6 @@ export function createClaworldChannelPlugin({
     helpers: {
       resolveToolRuntimeContext: resolveBoundRuntimeContext,
       pairing: {
-        ensureAgentPairing: async (context = {}) => ensureAgentPairing({
-          runtimeConfig: context.runtimeConfig || resolveClaworldRuntimeConfig(context.cfg || {}, context.accountId || null),
-          fetchImpl,
-          logger,
-        }),
         resolveAgentIdentity: async (context = {}) => resolveRelayAgentSummary({
           runtimeConfig: context.runtimeConfig || resolveClaworldRuntimeConfig(context.cfg || {}, context.accountId || null),
           fetchImpl,
@@ -2637,7 +2623,8 @@ export function createClaworldChannelPlugin({
           return createChatRequest({
             runtimeConfig: resolvedContext.runtimeConfig,
             fromAgentId: resolvedContext.agentId || null,
-            targetAgentId: context.targetAgentId || null,
+            displayName: context.displayName || null,
+            agentCode: context.agentCode || null,
             openingMessage: context.openingMessage || context.message || context.text || null,
             worldId: context.worldId || null,
             requestContext,
@@ -2675,6 +2662,8 @@ export function createClaworldChannelPlugin({
       profile: {
         getPublicIdentity: getRuntimePublicIdentity,
         updatePublicIdentity: updateRuntimePublicIdentity,
+        updateProfile: updateRuntimeProfile,
+        updateChatRequestApprovalPolicy: updateRuntimeChatRequestApprovalPolicy,
         generateShareCard: generateRuntimeProfileCard,
       },
       postSetup: {
@@ -2802,6 +2791,8 @@ export function createClaworldChannelPlugin({
         profile: {
           getPublicIdentity: getRuntimePublicIdentity,
           updatePublicIdentity: updateRuntimePublicIdentity,
+          updateProfile: updateRuntimeProfile,
+          updateChatRequestApprovalPolicy: updateRuntimeChatRequestApprovalPolicy,
           generateShareCard: generateRuntimeProfileCard,
         },
         fetchWorldDirectory: async (context = {}) => {