@xfxstudio/claworld 2026.4.14-testing.1 → 2026.4.16-testing.1

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

@@ -1,728 +0,0 @@
-import {
-  projectToolChatInboxResponse,
-  projectToolChatRequestMutationResponse,
-  projectToolManagedWorldResponse,
-  projectToolOwnedWorldsResponse,
-  projectToolWorldBroadcastResponse,
-  projectToolWorldMembershipListResponse,
-  projectToolWorldMembershipResponse,
-} from '../runtime/tool-contracts.js';
-import {
-  buildPublicErrorPayload,
-  createRuntimeBoundaryError,
-  logRuntimeBoundary,
-  normalizeRuntimeBoundaryError,
-} from '../../lib/runtime-errors.js';
-import {
-  normalizeBackendFieldError,
-  normalizeBackendMissingField,
-  normalizeBackendPublicIdentity,
-} from '../runtime/backend-error-context.js';
-
-export const INTERNAL_REQUESTER_SESSION_KEY_PARAM = '__claworldRequesterSessionKey';
-
-export function normalizeText(value, fallback = null) {
-  if (value == null) return fallback;
-  const normalized = String(value).trim();
-  return normalized || fallback;
-}
-
-export function normalizeObject(value, fallback = null) {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return fallback;
-  return value;
-}
-
-function resolveRuntimeAppToken(runtimeConfig = {}) {
-  return normalizeText(
-    runtimeConfig?.appToken,
-    normalizeText(
-      runtimeConfig?.relay?.appToken,
-      normalizeText(runtimeConfig?.relay?.credentialToken, null),
-    ),
-  );
-}
-
-async function buildPendingPublicIdentityError({
-  plugin,
-  cfg,
-  accountId,
-  runtimeConfig,
-  agentId = null,
-  capability,
-} = {}) {
-  const getPublicIdentity = plugin?.runtime?.productShell?.profile?.getPublicIdentity;
-  const capabilityLabel = normalizeText(capability, 'this Claworld capability');
-  const fallbackMessage = `${capabilityLabel} requires a public Claworld identity`;
-  if (typeof getPublicIdentity !== 'function') {
-    return createRuntimeBoundaryError({
-      code: 'public_identity_incomplete',
-      category: 'conflict',
-      status: 409,
-      message: fallbackMessage,
-      publicMessage: fallbackMessage,
-      recoverable: true,
-      context: {
-        accountId: normalizeText(accountId, null),
-        agentId: normalizeText(agentId, null),
-        httpStatus: 409,
-        backendCode: 'public_identity_incomplete',
-        backendMessage: fallbackMessage,
-        requiredAction: 'set_public_identity',
-        nextAction: 'set_public_identity',
-        nextTool: 'claworld_account',
-      },
-    });
-  }
-
-  const identityPayload = await getPublicIdentity({
-    cfg,
-    accountId,
-    runtimeConfig,
-    agentId: normalizeText(agentId, null),
-    generateShareCard: false,
-    expiresInSeconds: null,
-  });
-  const publicMessage = normalizeText(identityPayload?.message, fallbackMessage);
-  return createRuntimeBoundaryError({
-    code: 'public_identity_incomplete',
-    category: 'conflict',
-    status: 409,
-    message: publicMessage,
-    publicMessage,
-    recoverable: true,
-    context: {
-      accountId: normalizeText(accountId, null),
-      agentId: normalizeText(
-        agentId,
-        normalizeText(identityPayload?.agentId, null),
-      ),
-      httpStatus: 409,
-      backendCode: 'public_identity_incomplete',
-      backendMessage: publicMessage,
-      requiredAction: normalizeText(identityPayload?.requiredAction, 'set_public_identity'),
-      nextAction: normalizeText(identityPayload?.nextAction, 'set_public_identity'),
-      nextTool: normalizeText(identityPayload?.nextTool, 'claworld_account'),
-      missingFields: Array.isArray(identityPayload?.missingFields) ? identityPayload.missingFields : [],
-      publicIdentity: normalizeObject(identityPayload?.publicIdentity, null),
-    },
-  });
-}
-
-function normalizePublicFieldError(fieldError = {}) {
-  const fieldId = normalizeText(fieldError.fieldId, null);
-  const message = normalizeText(fieldError.message, null);
-  const code = normalizeText(fieldError.code, null);
-  if (!fieldId && !message && !code) return null;
-  return {
-    ...(fieldId ? { fieldId } : {}),
-    ...(message ? { message } : {}),
-    ...(code ? { code } : {}),
-  };
-}
-
-export function buildPublicToolErrorExtras(error) {
-  const context = normalizeObject(error?.context, null);
-  if (!context) return null;
-
-  const httpStatus = Number(context.httpStatus);
-  const backendCode = normalizeText(context.backendCode, null);
-  const backendMessage = normalizeText(context.backendMessage, null);
-  const fieldErrors = Array.isArray(context.fieldErrors)
-    ? context.fieldErrors
-      .map((fieldError) => normalizeBackendFieldError(fieldError) || normalizePublicFieldError(fieldError))
-      .filter(Boolean)
-    : [];
-  const requiredAction = normalizeText(context.requiredAction, null);
-  const nextAction = normalizeText(context.nextAction, null);
-  const nextTool = normalizeText(context.nextTool, null);
-  const missingFields = Array.isArray(context.missingFields)
-    ? context.missingFields
-      .map((field) => normalizeBackendMissingField(field))
-      .filter(Boolean)
-    : [];
-  const publicIdentity = normalizeBackendPublicIdentity(context.publicIdentity);
-
-  const extra = {
-    ...(Number.isInteger(httpStatus) && httpStatus > 0 ? { httpStatus } : {}),
-    ...(backendCode ? { backendCode } : {}),
-    ...(backendMessage ? { backendMessage } : {}),
-    ...(fieldErrors.length > 0 ? { fieldErrors } : {}),
-    ...(requiredAction ? { requiredAction } : {}),
-    ...(nextAction ? { nextAction } : {}),
-    ...(nextTool ? { nextTool } : {}),
-    ...(missingFields.length > 0 ? { missingFields } : {}),
-    ...(publicIdentity ? { publicIdentity } : {}),
-  };
-
-  return Object.keys(extra).length > 0 ? extra : null;
-}
-
-export async function loadCurrentConfig(api) {
-  if (api?.config && typeof api.config.loadConfig === 'function') {
-    return await api.config.loadConfig();
-  }
-  if (api?.runtime?.config && typeof api.runtime.config.loadConfig === 'function') {
-    return await api.runtime.config.loadConfig();
-  }
-  if (api?.config && typeof api.config === 'object') {
-    return api.config;
-  }
-  return {};
-}
-
-export function buildToolResult(payload) {
-  return {
-    content: [
-      {
-        type: 'text',
-        text: JSON.stringify(payload, null, 2),
-      },
-    ],
-  };
-}
-
-export function buildToolErrorResult(toolName, error) {
-  const normalized = normalizeRuntimeBoundaryError(error, {
-    code: 'claworld_tool_execution_failed',
-    category: 'runtime',
-    publicMessage: 'tool execution failed',
-    recoverable: true,
-  });
-  return buildToolResult({
-    status: 'error',
-    tool: toolName,
-    ...buildPublicErrorPayload(normalized, {
-      errorType: 'claworld_tool_failed',
-      fallbackMessage: 'tool execution failed',
-      exposeMessage: normalized.status < 500 || Boolean(normalized.publicMessage),
-      extra: buildPublicToolErrorExtras(normalized),
-    }),
-  });
-}
-
-export function withToolErrorBoundary(toolName, execute) {
-  return async (toolCallId, params = {}) => {
-    try {
-      return await execute(toolCallId, params);
-    } catch (error) {
-      const normalized = logRuntimeBoundary(console, `[claworld:tool:${toolName}] execution failed`, error, {
-        tool: toolName,
-      }, {
-        includeStack: false,
-        fallback: {
-          code: 'claworld_tool_execution_failed',
-          category: 'runtime',
-          publicMessage: 'tool execution failed',
-          recoverable: true,
-        },
-      });
-      return buildToolErrorResult(toolName, normalized);
-    }
-  };
-}
-
-export async function resolveToolContext(
-  api,
-  plugin,
-  params = {},
-  {
-    bindRuntime = true,
-    requiredPublicIdentityCapability = null,
-  } = {},
-) {
-  const cfg = await loadCurrentConfig(api);
-  const accountId = normalizeText(params.accountId, plugin.config.defaultAccountId(cfg) || null);
-  const runtimeConfig = plugin.config.resolveRuntimeConfig(cfg, accountId);
-
-  if (bindRuntime && typeof plugin.helpers?.resolveToolRuntimeContext === 'function') {
-    const resolvedContext = await plugin.helpers.resolveToolRuntimeContext({
-      cfg,
-      accountId,
-      runtimeConfig,
-      agentId: normalizeText(params.agentId, runtimeConfig.relay?.agentId || null),
-      requesterSessionKey: normalizeText(params[INTERNAL_REQUESTER_SESSION_KEY_PARAM], null),
-    });
-    if (
-      requiredPublicIdentityCapability
-      && (
-        !normalizeText(resolvedContext?.agentId, null)
-        || !resolveRuntimeAppToken(resolvedContext?.runtimeConfig || runtimeConfig)
-      )
-    ) {
-      throw await buildPendingPublicIdentityError({
-        plugin,
-        cfg,
-        accountId: resolvedContext?.accountId || accountId,
-        runtimeConfig: resolvedContext?.runtimeConfig || runtimeConfig,
-        agentId: resolvedContext?.agentId || null,
-        capability: requiredPublicIdentityCapability,
-      });
-    }
-    return resolvedContext;
-  }
-
-  const agentId = normalizeText(params.agentId, runtimeConfig.relay?.agentId || null);
-  if (
-    requiredPublicIdentityCapability
-    && (!agentId || !resolveRuntimeAppToken(runtimeConfig))
-  ) {
-    throw await buildPendingPublicIdentityError({
-      plugin,
-      cfg,
-      accountId,
-      runtimeConfig,
-      agentId,
-      capability: requiredPublicIdentityCapability,
-    });
-  }
-  return {
-    cfg,
-    accountId,
-    runtimeConfig,
-    agentId,
-    requesterSessionKey: normalizeText(params[INTERNAL_REQUESTER_SESSION_KEY_PARAM], null),
-  };
-}
-
-export function cloneMetadataValue(value) {
-  return value == null ? value : JSON.parse(JSON.stringify(value));
-}
-
-export function stringParam({
-  description = null,
-  minLength = null,
-  enumValues = null,
-  pattern = null,
-  examples = [],
-} = {}) {
-  return {
-    type: 'string',
-    ...(description ? { description } : {}),
-    ...(Number.isInteger(minLength) && minLength > 0 ? { minLength } : {}),
-    ...(Array.isArray(enumValues) && enumValues.length > 0 ? { enum: enumValues } : {}),
-    ...(pattern ? { pattern } : {}),
-    ...(Array.isArray(examples) && examples.length > 0 ? { examples } : {}),
-  };
-}
-
-export function integerParam({
-  description = null,
-  minimum = null,
-  maximum = null,
-  examples = [],
-} = {}) {
-  return {
-    type: 'integer',
-    ...(description ? { description } : {}),
-    ...(Number.isInteger(minimum) ? { minimum } : {}),
-    ...(Number.isInteger(maximum) ? { maximum } : {}),
-    ...(Array.isArray(examples) && examples.length > 0 ? { examples } : {}),
-  };
-}
-
-export function booleanParam({
-  description = null,
-  defaultValue = null,
-} = {}) {
-  return {
-    type: 'boolean',
-    ...(description ? { description } : {}),
-    ...(typeof defaultValue === 'boolean' ? { default: defaultValue } : {}),
-  };
-}
-
-export function objectParam({
-  description = null,
-  properties = {},
-  required = [],
-  additionalProperties = false,
-  examples = [],
-} = {}) {
-  return {
-    type: 'object',
-    additionalProperties,
-    ...(description ? { description } : {}),
-    ...(Array.isArray(required) && required.length > 0 ? { required } : {}),
-    properties,
-    ...(Array.isArray(examples) && examples.length > 0 ? { examples: examples.map(cloneMetadataValue) } : {}),
-  };
-}
-
-export function arrayParam({
-  description = null,
-  items = {},
-  maxItems = null,
-  examples = [],
-} = {}) {
-  return {
-    type: 'array',
-    items,
-    ...(description ? { description } : {}),
-    ...(Number.isInteger(maxItems) ? { maxItems } : {}),
-    ...(Array.isArray(examples) && examples.length > 0 ? { examples: examples.map(cloneMetadataValue) } : {}),
-  };
-}
-
-export function buildToolMetadata({
-  category,
-  usageNotes = [],
-  examples = [],
-} = {}) {
-  return {
-    surface: 'canonical_public',
-    canonical: true,
-    category: normalizeText(category, 'general'),
-    usageNotes: Array.isArray(usageNotes) ? usageNotes.filter(Boolean) : [],
-    examples: Array.isArray(examples)
-      ? examples.map((example) => cloneMetadataValue(example)).filter(Boolean)
-      : [],
-  };
-}
-
-export const MANAGE_WORLD_ACTIONS = Object.freeze([
-  'list',
-  'get',
-  'broadcast',
-  'update_context',
-  'pause',
-  'close',
-  'resume',
-  'list_memberships',
-  'get_membership',
-  'update_profile',
-  'leave',
-]);
-
-export function normalizeManageWorldAction(value, fallback = null) {
-  const normalized = normalizeText(value, fallback);
-  return MANAGE_WORLD_ACTIONS.includes(normalized) ? normalized : fallback;
-}
-
-export function inferManageWorldAction(params = {}) {
-  const explicitAction = normalizeManageWorldAction(params.action, null);
-  if (explicitAction) return explicitAction;
-  if (!normalizeText(params.worldId, null)) return 'list';
-  if (normalizeText(params.announcementText, null)) return 'broadcast';
-  if (normalizeText(params.participantContextText, null)) return 'update_profile';
-  if (
-    normalizeText(params.worldContextText, null)
-    || normalizeText(params.displayName, null)
-    || normalizeObject(params.broadcast, null)
-  ) {
-    return 'update_context';
-  }
-  return 'get';
-}
-
-export function requireManageWorldField(fieldId, message = `${fieldId} is required`) {
-  throw createRuntimeBoundaryError({
-    code: 'tool_input_invalid',
-    category: 'input',
-    status: 400,
-    message,
-    publicMessage: message,
-    recoverable: true,
-    context: { field: fieldId },
-  });
-}
-
-export function projectToolManageWorldActionResponse(payload = {}, { accountId = null, action = null } = {}) {
-  const resolvedAction = normalizeManageWorldAction(action, null) || 'get';
-  if (resolvedAction === 'list') {
-    return {
-      action: resolvedAction,
-      ...projectToolOwnedWorldsResponse(payload, { accountId }),
-    };
-  }
-  if (resolvedAction === 'broadcast') {
-    return {
-      action: resolvedAction,
-      ...projectToolWorldBroadcastResponse(payload, { accountId }),
-    };
-  }
-  if (resolvedAction === 'list_memberships') {
-    return {
-      action: resolvedAction,
-      ...projectToolWorldMembershipListResponse(payload, { accountId }),
-    };
-  }
-  if (['get_membership', 'update_profile', 'leave'].includes(resolvedAction)) {
-    return {
-      action: resolvedAction,
-      ...projectToolWorldMembershipResponse(payload, { accountId }),
-    };
-  }
-  return {
-    action: resolvedAction,
-    ...projectToolManagedWorldResponse(payload, { accountId }),
-  };
-}
-
-export const CHAT_INBOX_ACTIONS = Object.freeze([
-  'list',
-  'accept',
-  'reject',
-]);
-
-function normalizeChatInboxAction(value, fallback = null) {
-  const normalized = normalizeText(value, fallback);
-  return CHAT_INBOX_ACTIONS.includes(normalized) ? normalized : fallback;
-}
-
-export function inferChatInboxAction(params = {}) {
-  return normalizeChatInboxAction(params.action, 'list');
-}
-
-export function projectToolChatInboxActionResponse(payload = {}, { accountId = null, action = 'list' } = {}) {
-  const resolvedAction = normalizeChatInboxAction(action, 'list');
-  if (resolvedAction === 'list') {
-    return {
-      action: resolvedAction,
-      ...projectToolChatInboxResponse(payload, { accountId }),
-    };
-  }
-  return {
-    action: resolvedAction,
-    ...projectToolChatRequestMutationResponse(payload, { accountId }),
-  };
-}
-
-export const ACCOUNT_ACTIONS = Object.freeze([
-  'view',
-  'update_identity',
-  'update_profile',
-  'update_chat_policy',
-]);
-
-function normalizeAccountAction(value, fallback = null) {
-  const normalized = normalizeText(value, fallback);
-  return ACCOUNT_ACTIONS.includes(normalized) ? normalized : fallback;
-}
-
-export function inferAccountAction(params = {}) {
-  const explicitAction = normalizeAccountAction(params.action, null);
-  if (explicitAction) return explicitAction;
-  if (normalizeText(params.displayName, null)) return 'update_identity';
-  if (Object.prototype.hasOwnProperty.call(params, 'profile')) return 'update_profile';
-  if (normalizeObject(params.chatRequestApprovalPolicy, null)) return 'update_chat_policy';
-  return 'view';
-}
-
-function projectToolPublicIdentity(payload = null) {
-  if (!payload || typeof payload !== 'object') return null;
-  return {
-    status: payload.status || null,
-    ready: payload.ready ?? null,
-    publicIdentity: payload.publicIdentity && typeof payload.publicIdentity === 'object'
-      ? {
-          status: payload.publicIdentity.status || null,
-          displayIdentity: payload.publicIdentity.displayIdentity || null,
-          displayName: payload.publicIdentity.displayName || null,
-          code: payload.publicIdentity.code || null,
-          confirmedAt: payload.publicIdentity.confirmedAt || null,
-          updatedAt: payload.publicIdentity.updatedAt || null,
-        }
-      : null,
-    recommendedDisplayName: payload.recommendedDisplayName || null,
-    requiredAction: payload.requiredAction || null,
-    nextAction: payload.nextAction || null,
-    nextTool: payload.nextTool || null,
-    missingFields: Array.isArray(payload.missingFields) ? payload.missingFields : [],
-    feedbackSummary: payload.feedbackSummary && typeof payload.feedbackSummary === 'object'
-      ? {
-          totalLikesReceived: Number(payload.feedbackSummary.totalLikesReceived || 0),
-          totalDislikesReceived: Number(payload.feedbackSummary.totalDislikesReceived || 0),
-          totalLikesGiven: Number(payload.feedbackSummary.totalLikesGiven || 0),
-          totalDislikesGiven: Number(payload.feedbackSummary.totalDislikesGiven || 0),
-        }
-      : null,
-  };
-}
-
-function projectToolShareCard(payload = null) {
-  const imageUrl = normalizeText(payload?.imageUrl, null);
-  const downloadUrl = normalizeText(payload?.downloadUrl, imageUrl);
-  const templateId = normalizeText(payload?.templateId, null);
-  const expiresAt = normalizeText(payload?.expiresAt, null);
-  const description = normalizeText(payload?.description, null);
-  if (!imageUrl && !downloadUrl && !templateId && !expiresAt && !description) {
-    return {
-      status: normalizeText(payload?.status, 'unavailable'),
-      reason: normalizeText(payload?.reason, null),
-      message: normalizeText(payload?.message, null),
-    };
-  }
-  return {
-    status: normalizeText(payload?.status, 'ready'),
-    imageUrl,
-    downloadUrl,
-    templateId,
-    expiresAt,
-    description,
-  };
-}
-
-function projectToolAccountIdentityFields(identityPayload = null) {
-  const projectedIdentity = projectToolPublicIdentity(identityPayload);
-  if (projectedIdentity) {
-    return {
-      publicIdentity: projectedIdentity.publicIdentity,
-      recommendedDisplayName: projectedIdentity.recommendedDisplayName,
-      requiredAction: projectedIdentity.requiredAction,
-      nextAction: projectedIdentity.nextAction,
-      nextTool: projectedIdentity.nextTool,
-      missingFields: projectedIdentity.missingFields,
-      feedbackSummary: projectedIdentity.feedbackSummary,
-    };
-  }
-  return {
-    publicIdentity: null,
-    recommendedDisplayName: null,
-    requiredAction: null,
-    nextAction: null,
-    nextTool: null,
-    missingFields: [],
-    feedbackSummary: null,
-  };
-}
-
-function projectToolAccountProfile(identityPayload = null) {
-  return normalizeText(identityPayload?.profile, null);
-}
-
-function projectToolChatRequestApprovalPolicy(payload = null) {
-  const policy = normalizeObject(payload, null);
-  if (!policy) return null;
-  return {
-    agentId: normalizeText(policy.agentId, null),
-    schemaVersion: Number.isInteger(policy.schemaVersion) ? policy.schemaVersion : null,
-    syncedAt: normalizeText(policy.syncedAt, null),
-    credentialId: normalizeText(policy.credentialId, null),
-    source: normalizeObject(policy.source, {})
-      ? {
-          channel: normalizeText(policy.source?.channel, null),
-          integration: normalizeText(policy.source?.integration, null),
-          accountId: normalizeText(policy.source?.accountId, null),
-        }
-      : {},
-    policy: normalizeObject(policy.policy, {})
-      ? {
-          mode: normalizeText(policy.policy?.mode, null),
-          blocks: {
-            originTypes: Array.isArray(policy.policy?.blocks?.originTypes) ? policy.policy.blocks.originTypes : [],
-            worldIds: Array.isArray(policy.policy?.blocks?.worldIds) ? policy.policy.blocks.worldIds : [],
-          },
-        }
-      : null,
-  };
-}
-
-function projectToolPluginVersionStatus(payload = null) {
-  const versionStatus = normalizeObject(payload, null);
-  if (!versionStatus) return null;
-
-  const warning = normalizeObject(versionStatus.warning, null);
-  return {
-    reportedVersion: normalizeText(versionStatus.reportedVersion, null),
-    minSupportedVersion: normalizeText(versionStatus.minSupportedVersion, null),
-    latestVersion: normalizeText(versionStatus.latestVersion, null),
-    compatible: typeof versionStatus.compatible === 'boolean' ? versionStatus.compatible : null,
-    status: normalizeText(versionStatus.status, 'unknown'),
-    upgradeCommand: normalizeText(versionStatus.upgradeCommand, null),
-    message: normalizeText(versionStatus.message, null),
-    ...(warning
-      ? {
-          warning: {
-            level: normalizeText(warning.level, null),
-            code: normalizeText(warning.code, null),
-            message: normalizeText(warning.message, null),
-          },
-        }
-      : {}),
-  };
-}
-
-export function projectToolAccountViewResponse({
-  accountId = null,
-  pairingPayload = null,
-  identityPayload = null,
-} = {}) {
-  const identityReady = identityPayload?.ready === true;
-  const ready = pairingPayload?.status === 'paired' && identityReady;
-  const resolvedShareCard = identityPayload && Object.prototype.hasOwnProperty.call(identityPayload, 'shareCard')
-    ? projectToolShareCard(identityPayload.shareCard)
-    : undefined;
-  return {
-    action: 'view',
-    status: ready ? 'ready' : 'pending',
-    ready,
-    readiness: pairingPayload?.status === 'paired'
-      ? (identityReady ? 'paired_and_ready' : 'paired_but_identity_pending')
-      : 'installed_unactivated',
-    accountId: normalizeText(pairingPayload?.runtimeConfig?.accountId, normalizeText(accountId, null)),
-    reason: normalizeText(pairingPayload?.reason, null),
-    bindingSource: normalizeText(pairingPayload?.bindingSource, null),
-    activation: {
-      status: pairingPayload?.status === 'paired' ? 'ready' : 'pending',
-    },
-    relay: {
-      agentId: normalizeText(
-        pairingPayload?.runtimeConfig?.relay?.agentId,
-        normalizeText(pairingPayload?.relayAgent?.agentId, null),
-      ),
-      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',
-    },
-    profile: projectToolAccountProfile(identityPayload),
-    ...projectToolAccountIdentityFields(identityPayload),
-    pluginVersionStatus: projectToolPluginVersionStatus(identityPayload?.pluginVersionStatus),
-    chatRequestApprovalPolicy: projectToolChatRequestApprovalPolicy(identityPayload?.chatRequestApprovalPolicy),
-    ...(resolvedShareCard !== undefined ? { shareCard: resolvedShareCard } : {}),
-  };
-}
-
-export function projectToolAccountMutationResponse({
-  action = 'update_identity',
-  accountId = null,
-  identityPayload = null,
-  shareCard = undefined,
-  runtimeActivation = null,
-} = {}) {
-  const resolvedShareCard = shareCard !== undefined
-    ? shareCard
-    : (identityPayload && Object.prototype.hasOwnProperty.call(identityPayload, 'shareCard')
-        ? projectToolShareCard(identityPayload.shareCard)
-        : undefined);
-  const ready = identityPayload?.ready === true;
-  return {
-    action,
-    status: ready ? 'ready' : 'pending',
-    ready,
-    accountId: normalizeText(accountId, null),
-    profile: projectToolAccountProfile(identityPayload),
-    ...projectToolAccountIdentityFields(identityPayload),
-    pluginVersionStatus: projectToolPluginVersionStatus(identityPayload?.pluginVersionStatus),
-    chatRequestApprovalPolicy: projectToolChatRequestApprovalPolicy(identityPayload?.chatRequestApprovalPolicy),
-    ...(resolvedShareCard !== undefined ? { shareCard: resolvedShareCard } : {}),
-    ...(runtimeActivation ? { runtimeActivation } : {}),
-    ...(action === 'update_identity'
-      ? {
-          updated: resolvedShareCard && resolvedShareCard.status === 'ready'
-            ? ['publicIdentity', 'shareCard']
-            : ['publicIdentity'],
-        }
-      : action === 'update_profile'
-        ? {
-            updated: ['profile'],
-          }
-        : action === 'update_chat_policy'
-          ? {
-              updated: ['chatRequestApprovalPolicy'],
-            }
-          : {}),
-  };
-}