@xfxstudio/claworld 0.1.0

package/src/product-shell/social/chat-request-service.js

@@ -0,0 +1,632 @@
+import { normalizeAgentProfile, resolveAgentDisplayName, resolveAgentVisibility } from '../../lib/agent-profile.js';
+import { createKickoffBrief, resolveStoredKickoffBrief } from '../../lib/accepted-chat-kickoff.js';
+import { WORLD_ACTIONS } from '../worlds/world-authorization.js';
+import { normalizeChatRequestApprovalPolicy } from '../contracts/chat-request-approval-policy.js';
+import {
+  createStoredChatRequestApprovalPolicy,
+  evaluateChatRequestApprovalPolicy,
+} from './chat-request-approval-policy.js';
+
+function normalizeText(value, fallback = null) {
+  if (value == null) return fallback;
+  const normalized = String(value).trim();
+  return normalized || fallback;
+}
+
+function normalizeDirection(direction) {
+  const normalized = normalizeText(direction, null);
+  return normalized === 'inbound' || normalized === 'outbound' ? normalized : null;
+}
+
+function normalizePositiveInteger(value, fallback = null) {
+  const normalized = Number(value);
+  if (!Number.isFinite(normalized) || normalized <= 0) return fallback;
+  return Math.max(1, Math.trunc(normalized));
+}
+
+function cloneJsonObject(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  try {
+    const cloned = JSON.parse(JSON.stringify(value));
+    if (!cloned || typeof cloned !== 'object' || Array.isArray(cloned)) return null;
+    return cloned;
+  } catch {
+    return null;
+  }
+}
+
+function normalizeConversationWorldId(value) {
+  return normalizeText(value, null);
+}
+
+function parseEpisodePolicy(episodePolicy = null) {
+  if (episodePolicy == null) return { value: null, error: null };
+  if (!episodePolicy || typeof episodePolicy !== 'object' || Array.isArray(episodePolicy)) {
+    return {
+      value: null,
+      error: {
+        code: 'chat_request_episode_policy_invalid',
+        message: 'episodePolicy must be an object',
+      },
+    };
+  }
+
+  const hasMaxTurns = Object.prototype.hasOwnProperty.call(episodePolicy, 'maxTurns');
+  const hasTurnTimeoutMs = Object.prototype.hasOwnProperty.call(episodePolicy, 'turnTimeoutMs');
+  const hasRaiseHandPolicy = Object.prototype.hasOwnProperty.call(episodePolicy, 'raiseHandPolicy');
+
+  const maxTurns = !hasMaxTurns
+    ? null
+    : episodePolicy.maxTurns === null
+      ? null
+      : normalizePositiveInteger(episodePolicy.maxTurns, null);
+  if (hasMaxTurns && episodePolicy.maxTurns != null && maxTurns == null) {
+    return {
+      value: null,
+      error: {
+        code: 'chat_request_episode_policy_invalid',
+        message: 'episodePolicy.maxTurns must be a positive integer',
+      },
+    };
+  }
+
+  const turnTimeoutMs = !hasTurnTimeoutMs
+    ? null
+    : episodePolicy.turnTimeoutMs === null
+      ? null
+      : normalizePositiveInteger(episodePolicy.turnTimeoutMs, null);
+  if (hasTurnTimeoutMs && episodePolicy.turnTimeoutMs != null && turnTimeoutMs == null) {
+    return {
+      value: null,
+      error: {
+        code: 'chat_request_episode_policy_invalid',
+        message: 'episodePolicy.turnTimeoutMs must be a positive integer',
+      },
+    };
+  }
+
+  if (
+    hasRaiseHandPolicy
+    && episodePolicy.raiseHandPolicy != null
+    && (
+      typeof episodePolicy.raiseHandPolicy !== 'object'
+      || Array.isArray(episodePolicy.raiseHandPolicy)
+    )
+  ) {
+    return {
+      value: null,
+      error: {
+        code: 'chat_request_episode_policy_invalid',
+        message: 'episodePolicy.raiseHandPolicy must be an object',
+      },
+    };
+  }
+
+  const raiseHandPolicy = cloneJsonObject(episodePolicy.raiseHandPolicy);
+  const value = {
+    ...(maxTurns != null ? { maxTurns } : {}),
+    ...(turnTimeoutMs != null ? { turnTimeoutMs } : {}),
+    ...(raiseHandPolicy ? { raiseHandPolicy } : {}),
+  };
+
+  return {
+    value: Object.keys(value).length > 0 ? value : null,
+    error: null,
+  };
+}
+
+function projectEpisodePolicy(conversation = {}) {
+  const parsed = parseEpisodePolicy(conversation);
+  return parsed.error ? null : parsed.value;
+}
+
+function sortByRecency(items = [], ...fieldNames) {
+  return items.slice().sort((left, right) => {
+    for (const fieldName of fieldNames) {
+      const rightTs = Date.parse(right?.[fieldName] || '');
+      const leftTs = Date.parse(left?.[fieldName] || '');
+      const normalizedRightTs = Number.isFinite(rightTs) ? rightTs : -Infinity;
+      const normalizedLeftTs = Number.isFinite(leftTs) ? leftTs : -Infinity;
+      if (normalizedRightTs !== normalizedLeftTs) return normalizedRightTs - normalizedLeftTs;
+    }
+    return String(right?.requestId || '').localeCompare(String(left?.requestId || ''));
+  });
+}
+
+function createConfigurationError(code = 'chat_request_service_unavailable') {
+  const error = new Error(code);
+  error.code = code;
+  error.status = 500;
+  return error;
+}
+
+function createAgentNotFoundError(agentId) {
+  const error = new Error(`agent_not_found:${agentId}`);
+  error.code = 'agent_not_found';
+  error.status = 404;
+  return error;
+}
+
+function createTargetAddressNotFoundError(targetAgentId) {
+  const error = new Error(`chat_request_target_not_found:${targetAgentId}`);
+  error.code = 'chat_request_target_not_found';
+  error.status = 404;
+  error.responseBody = {
+    error: error.code,
+    message: 'chat request target is not available',
+    targetAgentId: normalizeText(targetAgentId, null),
+  };
+  return error;
+}
+
+function createInvalidChatRequestError(code, message, extra = {}) {
+  const error = new Error(code);
+  error.code = code;
+  error.status = 400;
+  error.responseBody = {
+    error: code,
+    message,
+    ...extra,
+  };
+  return error;
+}
+
+function createWorldChatRequestMembershipNotActiveError(worldId, agentId) {
+  const error = new Error(`world_chat_request_membership_not_active:${worldId}:${agentId}`);
+  error.code = 'world_chat_request_membership_not_active';
+  error.status = 409;
+  error.responseBody = {
+    error: error.code,
+    message: 'agent must have an active world membership before creating a world-scoped chat request',
+    worldId: normalizeText(worldId, null),
+    agentId: normalizeText(agentId, null),
+    requiredMembershipStatus: 'active',
+  };
+  return error;
+}
+
+function createRelayResponseError(result = {}, fallbackCode = 'chat_request_failed') {
+  const code = normalizeText(result?.body?.error, fallbackCode);
+  const error = new Error(code);
+  error.code = code;
+  error.status = Number.isInteger(result?.status) ? result.status : 500;
+  error.responseBody = result?.body && typeof result.body === 'object'
+    ? result.body
+    : { error: code };
+  return error;
+}
+
+function projectAgent(store, agentId, presence = null) {
+  if (!store || !agentId) return null;
+  const agent = store.getAgent(agentId);
+  if (!agent) return null;
+  const visibility = resolveAgentVisibility(agent);
+  const presenceState = presence?.getPresence?.(agent.agentId) || store.getPresence(agent.agentId);
+  return {
+    agentId: agent.agentId,
+    agentCode: agent.agentCode,
+    domain: agent.domain,
+    address: agent.address,
+    displayName: resolveAgentDisplayName(agent),
+    profile: normalizeAgentProfile(agent.profile),
+    discoverable: visibility.discoverable,
+    contactable: visibility.contactable,
+    createdAt: agent.createdAt,
+    ...presenceState,
+  };
+}
+
+function projectWorldSummary(worldService, worldId) {
+  const normalizedWorldId = normalizeText(worldId, null);
+  if (!normalizedWorldId) return null;
+  const world = worldService?.getWorld?.(normalizedWorldId) || null;
+  if (!world) {
+    return {
+      worldId: normalizedWorldId,
+      slug: null,
+      displayName: null,
+      summary: null,
+    };
+  }
+  return {
+    worldId: world.worldId,
+    slug: world.slug || null,
+    displayName: world.displayName || null,
+    summary: world.summary || null,
+  };
+}
+
+function projectKickoffBrief(brief = null) {
+  if (!brief || typeof brief !== 'object' || Array.isArray(brief)) return null;
+  return {
+    text: normalizeText(brief.text, null),
+    payload: cloneJsonObject(brief.payload),
+    source: normalizeText(brief.source, 'chat_request_brief'),
+  };
+}
+
+function resolveKickoffBrief(request = {}, requestContext = {}) {
+  const directBrief = request.kickoffBrief && typeof request.kickoffBrief === 'object' && !Array.isArray(request.kickoffBrief)
+    ? request.kickoffBrief
+    : null;
+  return directBrief || resolveStoredKickoffBrief(requestContext);
+}
+
+function resolveOpeningMessage(request = {}, requestContext = {}) {
+  return normalizeText(
+    resolveKickoffBrief(request, requestContext)?.text,
+    normalizeText(
+      request?.openingMessage,
+      normalizeText(requestContext.openingPayload?.text, normalizeText(requestContext.message, null)),
+    ),
+  );
+}
+
+function projectKickoff(kickoff = {}) {
+  if (!kickoff || typeof kickoff !== 'object') return null;
+  return {
+    status: normalizeText(kickoff.status, 'skipped'),
+    deliveredAt: normalizeText(kickoff.deliveredAt, null),
+    reason: normalizeText(kickoff.reason, null),
+  };
+}
+
+function resolveAcceptNextAction(kickoff) {
+  const kickoffStatus = kickoff?.status || 'skipped';
+  if (kickoffStatus === 'sent') return 'runtime_owns_live_conversation';
+  if (kickoffStatus === 'failed') return 'backend_kickoff_failed';
+  return 'chat_request_accepted_without_opening_message';
+}
+
+function resolveCreateNextAction({ verdict = 'pending', kickoff = null } = {}) {
+  if (verdict === 'auto_accept') return resolveAcceptNextAction(kickoff);
+  if (verdict === 'reject') return 'request_rejected_by_policy';
+  return 'wait_for_peer_acceptance';
+}
+
+function normalizeChatRequestOrigin(origin = {}) {
+  if (!origin || typeof origin !== 'object' || Array.isArray(origin)) return null;
+  const type = normalizeText(origin.type, null);
+  const broadcastId = normalizeText(origin.broadcastId, null);
+  if (!type && !broadcastId) return null;
+  return {
+    ...(type ? { type } : {}),
+    ...(broadcastId ? { broadcastId } : {}),
+  };
+}
+
+function normalizeChatRequestBroadcastMetadata(broadcast = {}) {
+  if (!broadcast || typeof broadcast !== 'object' || Array.isArray(broadcast)) return null;
+  const broadcastId = normalizeText(broadcast.broadcastId, null);
+  if (!broadcastId) return null;
+  return {
+    broadcastId,
+    ...(normalizeText(broadcast.worldId, null) ? { worldId: normalizeText(broadcast.worldId, null) } : {}),
+    ...(normalizeText(broadcast.audience, null) ? { audience: normalizeText(broadcast.audience, null) } : {}),
+    ...(normalizeText(broadcast.senderRole, null) ? { senderRole: normalizeText(broadcast.senderRole, null) } : {}),
+    ...(normalizeText(broadcast.eligibility, null) ? { eligibility: normalizeText(broadcast.eligibility, null) } : {}),
+    ...(typeof broadcast.excludeSelf === 'boolean' ? { excludeSelf: broadcast.excludeSelf } : {}),
+  };
+}
+
+function projectStoredApprovalPolicy(record = {}) {
+  if (!record || typeof record !== 'object' || Array.isArray(record)) return null;
+  return {
+    agentId: normalizeText(record.agentId, null),
+    schemaVersion: Number.isInteger(record.schemaVersion) ? record.schemaVersion : null,
+    syncedAt: normalizeText(record.syncedAt, null),
+    credentialId: normalizeText(record.credentialId, null),
+    source: record.source && typeof record.source === 'object' && !Array.isArray(record.source)
+      ? {
+          channel: normalizeText(record.source.channel, null),
+          integration: normalizeText(record.source.integration, null),
+          accountId: normalizeText(record.source.accountId, null),
+        }
+      : {},
+    policy: normalizeChatRequestApprovalPolicy(record.policy || {}),
+  };
+}
+
+function projectChatRequestOrigin(request = {}) {
+  const directOrigin = request.origin && typeof request.origin === 'object' && !Array.isArray(request.origin)
+    ? request.origin
+    : null;
+  if (directOrigin) {
+    return {
+      type: normalizeText(directOrigin.type, normalizeText(request.source, 'chat_request')),
+      broadcastId: normalizeText(directOrigin.broadcastId, null),
+    };
+  }
+
+  const requestContext = request.requestContext && typeof request.requestContext === 'object' && !Array.isArray(request.requestContext)
+    ? request.requestContext
+    : {};
+  const origin = requestContext.origin && typeof requestContext.origin === 'object' && !Array.isArray(requestContext.origin)
+    ? requestContext.origin
+    : {};
+  const broadcast = requestContext.broadcast && typeof requestContext.broadcast === 'object' && !Array.isArray(requestContext.broadcast)
+    ? requestContext.broadcast
+    : {};
+  const broadcastId = normalizeText(origin.broadcastId, normalizeText(broadcast.broadcastId, null));
+  const source = normalizeText(request.source, null);
+  const type = normalizeText(origin.type, source === 'world_broadcast' ? 'world_broadcast' : 'chat_request');
+  return {
+    type,
+    broadcastId,
+  };
+}
+
+export function createChatRequestService({
+  store = null,
+  relay = null,
+  presence = null,
+  worldService = null,
+  worldAuthorizationService = null,
+} = {}) {
+  function assertStore() {
+    if (!store) throw createConfigurationError('chat_request_store_unavailable');
+    return store;
+  }
+
+  function assertRelay(methodName) {
+    if (!relay || typeof relay[methodName] !== 'function') {
+      throw createConfigurationError('chat_request_relay_unavailable');
+    }
+    return relay;
+  }
+
+  function requireAgent(agentId) {
+    const normalizedAgentId = normalizeText(agentId, null);
+    if (!normalizedAgentId) throw createAgentNotFoundError(agentId);
+    const agent = assertStore().getAgent(normalizedAgentId);
+    if (!agent) throw createAgentNotFoundError(normalizedAgentId);
+    return agent;
+  }
+
+  function projectChatRequest(request = {}, viewerAgentId = null) {
+    const requestContext = request.requestContext && typeof request.requestContext === 'object' && !Array.isArray(request.requestContext)
+      ? request.requestContext
+      : {};
+    const conversation = request.conversation && typeof request.conversation === 'object' && !Array.isArray(request.conversation)
+      ? request.conversation
+      : {};
+    const worldId = normalizeConversationWorldId(conversation.worldId)
+      || normalizeConversationWorldId(requestContext.conversation?.worldId);
+    const episodePolicy = projectEpisodePolicy(conversation)
+      || projectEpisodePolicy(requestContext.conversation || {});
+    const counterpartyAgentId =
+      viewerAgentId === request.fromAgentId
+        ? request.toAgentId
+        : viewerAgentId === request.toAgentId
+          ? request.fromAgentId
+          : null;
+
+    return {
+      chatRequestId: normalizeText(request.chatRequestId || request.requestId, null),
+      status: normalizeText(request.status, 'pending'),
+      direction:
+        viewerAgentId === request.fromAgentId
+          ? 'outbound'
+          : viewerAgentId === request.toAgentId
+          ? 'inbound'
+            : 'related',
+      openingMessage: resolveOpeningMessage(request, requestContext),
+      kickoffBrief: projectKickoffBrief(resolveKickoffBrief(request, requestContext)),
+      createdAt: normalizeText(request.createdAt, null),
+      respondedAt: normalizeText(request.respondedAt, null),
+      expiresAt: normalizeText(request.expiresAt, null),
+      origin: projectChatRequestOrigin(request),
+      fromAgent: projectAgent(assertStore(), request.fromAgentId, presence),
+      toAgent: projectAgent(assertStore(), request.toAgentId, presence),
+      counterparty: projectAgent(assertStore(), counterpartyAgentId, presence),
+      conversation: {
+        mode: worldId ? 'world' : 'direct',
+        worldId,
+        world: projectWorldSummary(worldService, worldId),
+        ...(episodePolicy ? { episodePolicy } : {}),
+      },
+    };
+  }
+
+  return {
+    projectChatRequest,
+    async syncApprovalPolicy({
+      actorAgentId,
+      credentialId = null,
+      accountId = null,
+      approval = null,
+    } = {}) {
+      requireAgent(actorAgentId);
+      if (!assertStore().upsertChatRequestApprovalPolicy) {
+        throw createConfigurationError('chat_request_approval_policy_store_unavailable');
+      }
+
+      const record = await assertStore().upsertChatRequestApprovalPolicy(
+        createStoredChatRequestApprovalPolicy({
+          agentId: actorAgentId,
+          credentialId,
+          syncedAt: assertStore().now(),
+          policy: normalizeChatRequestApprovalPolicy(approval || {}),
+          source: {
+            channel: 'claworld',
+            integration: 'openclaw_plugin',
+            accountId,
+          },
+        }),
+      );
+
+      return {
+        status: 'synced',
+        approvalPolicy: projectStoredApprovalPolicy(record),
+      };
+    },
+    async createChatRequest({
+      fromAgentId,
+      targetAgentId,
+      kickoffBrief = null,
+      openingMessage = null,
+      openingPayload = null,
+      worldId = null,
+      episodePolicy = null,
+      origin = null,
+      broadcast = null,
+      source = 'chat_request',
+    } = {}) {
+      requireAgent(fromAgentId);
+      const normalizedTargetAgentId = normalizeText(targetAgentId, null);
+      if (!normalizedTargetAgentId) {
+        throw createInvalidChatRequestError('chat_request_target_required', 'chat request target requires targetAgentId');
+      }
+      const targetAgent = requireAgent(normalizedTargetAgentId);
+      const normalizedWorldId = normalizeConversationWorldId(worldId);
+      if (!targetAgent?.address) {
+        throw createTargetAddressNotFoundError(normalizedTargetAgentId);
+      }
+      const normalizedOpeningPayload = cloneJsonObject(openingPayload);
+      const normalizedKickoffBrief = createKickoffBrief({
+        text: typeof kickoffBrief === 'object' && kickoffBrief !== null && !Array.isArray(kickoffBrief)
+          ? kickoffBrief.text
+          : openingMessage,
+        payload: typeof kickoffBrief === 'object' && kickoffBrief !== null && !Array.isArray(kickoffBrief)
+          ? kickoffBrief.payload
+          : normalizedOpeningPayload,
+        source: typeof kickoffBrief === 'object' && kickoffBrief !== null && !Array.isArray(kickoffBrief)
+          ? kickoffBrief.source
+          : source === 'world_broadcast'
+            ? 'world_broadcast_brief'
+            : 'chat_request_brief',
+      });
+      const normalizedOrigin = normalizeChatRequestOrigin(origin);
+      const normalizedBroadcast = normalizeChatRequestBroadcastMetadata(broadcast);
+      const normalizedEpisodePolicy = parseEpisodePolicy(episodePolicy);
+      if (normalizedEpisodePolicy.error) {
+        throw createInvalidChatRequestError(
+          normalizedEpisodePolicy.error.code,
+          normalizedEpisodePolicy.error.message,
+        );
+      }
+      if (normalizedWorldId) {
+        if (normalizedEpisodePolicy.value) {
+          throw createInvalidChatRequestError(
+            'world_chat_request_episode_policy_not_supported',
+            'world-scoped chat requests inherit episode policy from the world template',
+          );
+        }
+        worldService?.requireWorld?.(normalizedWorldId);
+        if (normalizeText(source, 'chat_request') !== 'world_broadcast') {
+          const authorization = worldAuthorizationService.evaluateWorldAction({
+            worldId: normalizedWorldId,
+            actorAgentId: fromAgentId,
+            action: WORLD_ACTIONS.CREATE_CHAT_REQUEST,
+          });
+          if (!authorization.allowed || authorization.membership?.status !== 'active') {
+            throw createWorldChatRequestMembershipNotActiveError(normalizedWorldId, fromAgentId);
+          }
+        }
+      }
+
+      const result = await assertRelay('createChatRequest').createChatRequest({
+        fromAgentId,
+        toAddress: targetAgent.address,
+        kickoffBrief: normalizedKickoffBrief,
+        openingMessage: normalizeText(
+          normalizedKickoffBrief?.text,
+          normalizeText(openingMessage, null),
+        ),
+        openingPayload: cloneJsonObject(normalizedKickoffBrief?.payload) || normalizedOpeningPayload,
+        conversation: {
+          ...(normalizedWorldId ? { worldId: normalizedWorldId } : {}),
+          ...(normalizedEpisodePolicy.value || {}),
+        },
+        origin: normalizedOrigin,
+        broadcast: normalizedBroadcast,
+        source: normalizeText(source, 'chat_request'),
+      });
+      if (result.status < 200 || result.status >= 300) {
+        throw createRelayResponseError(result, 'chat_request_create_failed');
+      }
+
+      let storedRequest = result.body || {};
+      let kickoff = null;
+      const evaluation = evaluateChatRequestApprovalPolicy({
+        policyRecord: assertStore().getChatRequestApprovalPolicy?.(storedRequest.toAgentId) || null,
+        request: storedRequest,
+        store: assertStore(),
+        presence,
+        worldService,
+      });
+
+      if (evaluation.verdict === 'auto_accept') {
+        const accepted = await assertRelay('acceptChatRequest').acceptChatRequest(storedRequest.chatRequestId || storedRequest.requestId, {
+          actorAgentId: storedRequest.toAgentId,
+        });
+        if (accepted.status < 200 || accepted.status >= 300) {
+          throw createRelayResponseError(accepted, 'chat_request_auto_accept_failed');
+        }
+        storedRequest = accepted.body?.request || storedRequest;
+        kickoff = projectKickoff(accepted.body?.kickoff || storedRequest.kickoff);
+      } else if (evaluation.verdict === 'reject') {
+        const rejected = await assertRelay('rejectChatRequest').rejectChatRequest(storedRequest.chatRequestId || storedRequest.requestId, {
+          actorAgentId: storedRequest.toAgentId,
+        });
+        if (rejected.status < 200 || rejected.status >= 300) {
+          throw createRelayResponseError(rejected, 'chat_request_policy_reject_failed');
+        }
+        storedRequest = rejected.body || storedRequest;
+      }
+
+      return {
+        status: normalizeText(storedRequest.status, 'pending'),
+        verdict: evaluation.verdict,
+        reason: evaluation.reason,
+        chatRequest: projectChatRequest(storedRequest, fromAgentId),
+        ...(kickoff ? { kickoff } : {}),
+        nextAction: resolveCreateNextAction({
+          verdict: evaluation.verdict,
+          kickoff,
+        }),
+      };
+    },
+
+    listChatRequests({ agentId, direction = null } = {}) {
+      requireAgent(agentId);
+      const normalizedDirection = normalizeDirection(direction);
+      let items = assertStore().listChatRequests ? assertStore().listChatRequests() : [];
+      items = items.filter((request) => request.status === 'pending');
+      items = items.filter((request) => request.fromAgentId === agentId || request.toAgentId === agentId);
+      if (normalizedDirection === 'inbound') {
+        items = items.filter((request) => request.toAgentId === agentId);
+      } else if (normalizedDirection === 'outbound') {
+        items = items.filter((request) => request.fromAgentId === agentId);
+      }
+
+      return {
+        items: sortByRecency(items, 'createdAt').map((request) => projectChatRequest(request, agentId)),
+      };
+    },
+
+    async acceptChatRequest(chatRequestId, { actorAgentId } = {}) {
+      requireAgent(actorAgentId);
+      const normalizedChatRequestId = normalizeText(chatRequestId, null);
+      if (!normalizedChatRequestId) {
+        throw createInvalidChatRequestError('chat_request_id_required', 'chatRequestId is required');
+      }
+
+      const result = await assertRelay('acceptChatRequest').acceptChatRequest(normalizedChatRequestId, {
+        actorAgentId,
+      });
+      if (result.status < 200 || result.status >= 300) {
+        throw createRelayResponseError(result, 'chat_request_accept_failed');
+      }
+
+      const kickoff = projectKickoff(result.body?.kickoff || result.body?.request?.kickoff);
+      return {
+        status: 'accepted',
+        verdict: 'manual_accept',
+        chatRequest: projectChatRequest(result.body?.request || {}, actorAgentId),
+        kickoff,
+        nextAction: resolveAcceptNextAction(kickoff),
+      };
+    },
+  };
+}