@xfxstudio/claworld 0.2.13 → 0.2.14

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

@@ -1,723 +0,0 @@
-import { normalizeAgentProfile, resolveAgentDisplayName, resolveAgentVisibility } from '../../lib/agent-profile.js';
-import { normalizeChatRequestInput } from '../../lib/chat-request.js';
-import { resolvePublicIdentity } from '../../lib/public-identity.js';
-import { createKickoffBrief, resolveStoredKickoffBrief } from '../../lib/relay/kickoff-text.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 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 createTargetAgentNotFoundError(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,
-    displayName: resolveAgentDisplayName(agent),
-    publicIdentity: resolvePublicIdentity(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),
-    senderKickoffDeliveredAt: normalizeText(kickoff.senderKickoffDeliveredAt, normalizeText(kickoff.deliveredAt, null)),
-    openerAcceptedAt: normalizeText(kickoff.openerAcceptedAt, null),
-    openerDeliveredAt: normalizeText(kickoff.openerDeliveredAt, null),
-    liveChatEstablishedAt: normalizeText(kickoff.liveChatEstablishedAt, null),
-    reason: normalizeText(kickoff.reason, null),
-  };
-}
-
-function resolveAcceptNextAction(kickoff) {
-  const kickoffStatus = kickoff?.status || 'skipped';
-  if (kickoffStatus === 'established') return 'runtime_owns_live_conversation';
-  if (kickoffStatus === 'sent') return 'wait_for_sender_opener_delivery';
-  if (kickoffStatus === 'kept_silent') return 'sender_kept_silent';
-  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,
-  };
-}
-
-function hasConversationScope(conversation = null) {
-  return Boolean(conversation && typeof conversation === 'object' && !Array.isArray(conversation) && Object.keys(conversation).length > 0);
-}
-
-function resolveConversationLinkRequest(requests = [], conversation = {}) {
-  const conversationMeta = conversation?.meta && typeof conversation.meta === 'object' && !Array.isArray(conversation.meta)
-    ? conversation.meta
-    : {};
-  const approvalRequestId = normalizeText(conversationMeta.approvalRequestId, null);
-  if (approvalRequestId) {
-    return requests.find((request) => normalizeText(request.chatRequestId || request.requestId, null) === approvalRequestId) || null;
-  }
-
-  const conversationKey = normalizeText(conversation?.conversationKey, null);
-  if (!conversationKey) return null;
-
-  return requests.find((request) => {
-    const kickoff = request?.kickoff && typeof request.kickoff === 'object' && !Array.isArray(request.kickoff)
-      ? request.kickoff
-      : {};
-    return normalizeText(kickoff.conversationKey, null) === conversationKey
-      || normalizeText(request?.conversation?.conversationKey, null) === conversationKey;
-  }) || null;
-}
-
-function resolveInboxChatDirection(viewerAgentId, request = null) {
-  if (!request) return null;
-  if (viewerAgentId === request.fromAgentId) return 'outbound';
-  if (viewerAgentId === request.toAgentId) return 'inbound';
-  return 'related';
-}
-
-function resolveInboxChatCounterpartyAgentId(viewerAgentId, request = null, conversation = null) {
-  if (request) {
-    if (viewerAgentId === request.fromAgentId) return request.toAgentId;
-    if (viewerAgentId === request.toAgentId) return request.fromAgentId;
-  }
-
-  const participantIds = Array.isArray(conversation?.participantIds) ? conversation.participantIds : [];
-  return participantIds.find((participantId) => participantId && participantId !== viewerAgentId) || null;
-}
-
-function resolveInboxChatStatus(conversation = {}, request = null) {
-  const kickoffStatus = normalizeText(request?.kickoff?.status, null);
-  if (kickoffStatus === 'sent') return 'opening';
-  if (kickoffStatus === 'kept_silent') return 'silent';
-  if (kickoffStatus === 'failed') return 'kickoff_failed';
-  const conversationStatus = normalizeText(conversation?.status, 'active');
-  if (conversationStatus === 'active') return 'active';
-  if (conversationStatus === 'closed') return 'ended';
-  return conversationStatus;
-}
-
-function resolveInboxConversationWorldSummary(worldService, request = {}, conversation = {}) {
-  const requestContext = request?.requestContext && typeof request.requestContext === 'object' && !Array.isArray(request.requestContext)
-    ? request.requestContext
-    : {};
-  const requestConversation = request?.conversation && typeof request.conversation === 'object' && !Array.isArray(request.conversation)
-    ? request.conversation
-    : {};
-  const conversationMeta = conversation?.meta && typeof conversation.meta === 'object' && !Array.isArray(conversation.meta)
-    ? conversation.meta
-    : {};
-  const worldMeta = conversationMeta.world && typeof conversationMeta.world === 'object' && !Array.isArray(conversationMeta.world)
-    ? conversationMeta.world
-    : {};
-  const worldId = normalizeConversationWorldId(requestConversation.worldId)
-    || normalizeConversationWorldId(requestContext.conversation?.worldId)
-    || normalizeConversationWorldId(worldMeta.worldId)
-    || normalizeConversationWorldId(conversationMeta.worldId);
-
-  if (!worldId) {
-    return {
-      mode: 'direct',
-      worldId: null,
-      world: null,
-    };
-  }
-
-  return {
-    mode: 'world',
-    worldId,
-    world: projectWorldSummary(worldService, worldId),
-  };
-}
-
-export function createChatRequestService({
-  store = null,
-  relay = null,
-  presence = null,
-  worldService = null,
-  worldAuthorizationService = null,
-  publicIdentityService = null,
-  conversationFeedbackService = 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 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),
-      },
-    };
-  }
-
-  function projectChatInboxChat(conversation = {}, viewerAgentId = null, request = null) {
-    const direction = resolveInboxChatDirection(viewerAgentId, request);
-    const counterpartyAgentId = resolveInboxChatCounterpartyAgentId(viewerAgentId, request, conversation);
-    const feedbackSummary = conversationFeedbackService?.summarizeConversation?.({
-      conversationKey: conversation.conversationKey,
-      viewerAgentId,
-    }) || {
-      likeCount: 0,
-      dislikeCount: 0,
-      viewerGave: null,
-      viewerReceived: null,
-    };
-
-    return {
-      chatRequestId: normalizeText(request?.chatRequestId || request?.requestId, null),
-      status: resolveInboxChatStatus(conversation, request),
-      ...(direction ? { direction } : {}),
-      createdAt: normalizeText(conversation.createdAt, normalizeText(request?.createdAt, null)),
-      updatedAt: normalizeText(conversation.updatedAt, null),
-      lastTurnAt: normalizeText(conversation.lastTurnAt, null),
-      conversationKey: normalizeText(conversation.conversationKey, null),
-      localSessionKey: normalizeText(conversation.sessionKey, null),
-      counterparty: projectAgent(assertStore(), counterpartyAgentId, presence),
-      conversation: resolveInboxConversationWorldSummary(worldService, request, conversation),
-      feedbackSummary,
-    };
-  }
-
-  return {
-    projectChatRequest,
-    projectChatInboxChat,
-    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,
-      requestContext = null,
-      origin = null,
-      broadcast = null,
-      source = 'chat_request',
-    } = {}) {
-      requireAgent(fromAgentId);
-      publicIdentityService?.assertPublicIdentityReady?.({
-        agentId: fromAgentId,
-        capability: 'request chat',
-      });
-      const normalizedTargetAgentId = normalizeText(targetAgentId, null);
-      if (!normalizedTargetAgentId) {
-        throw createInvalidChatRequestError('chat_request_target_required', 'chat request target requires targetAgentId');
-      }
-      const targetAgent = requireAgent(normalizedTargetAgentId);
-      const normalizedSource = normalizeText(source, 'chat_request');
-      const normalizedRequestInput = normalizeChatRequestInput({
-        requestContext,
-        source: normalizedSource,
-      });
-      const normalizedWorldId = normalizeConversationWorldId(worldId)
-        || normalizeConversationWorldId(normalizedRequestInput.conversation?.worldId);
-      if (!targetAgent?.agentId) {
-        throw createTargetAgentNotFoundError(normalizedTargetAgentId);
-      }
-      const normalizedOpeningPayload = cloneJsonObject(openingPayload) || cloneJsonObject(normalizedRequestInput.openingPayload);
-      const normalizedKickoffBrief = createKickoffBrief({
-        text: typeof kickoffBrief === 'object' && kickoffBrief !== null && !Array.isArray(kickoffBrief)
-          ? kickoffBrief.text
-          : normalizeText(openingMessage, normalizeText(normalizedRequestInput.openingMessage, null)),
-        payload: typeof kickoffBrief === 'object' && kickoffBrief !== null && !Array.isArray(kickoffBrief)
-          ? kickoffBrief.payload
-          : normalizedOpeningPayload,
-        source: typeof kickoffBrief === 'object' && kickoffBrief !== null && !Array.isArray(kickoffBrief)
-          ? kickoffBrief.source
-          : normalizedSource === 'world_broadcast'
-            ? 'world_broadcast_brief'
-            : 'chat_request_brief',
-      });
-      const normalizedOrigin = normalizeChatRequestOrigin(origin) || normalizeChatRequestOrigin(normalizedRequestInput.origin);
-      const normalizedBroadcast = normalizeChatRequestBroadcastMetadata(broadcast)
-        || normalizeChatRequestBroadcastMetadata(normalizedRequestInput.broadcast);
-      if (normalizedWorldId) {
-        worldService?.requireWorld?.(normalizedWorldId);
-        if (normalizedSource !== '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,
-        targetAgentId: targetAgent.agentId,
-        kickoffBrief: normalizedKickoffBrief,
-        openingMessage: normalizeText(
-          normalizedKickoffBrief?.text,
-          normalizeText(openingMessage, null),
-        ),
-        openingPayload: cloneJsonObject(normalizedKickoffBrief?.payload) || normalizedOpeningPayload,
-        conversation: {
-          ...(normalizedWorldId ? { worldId: normalizedWorldId } : {}),
-        },
-        requestContext: cloneJsonObject(requestContext),
-        origin: normalizedOrigin,
-        broadcast: normalizedBroadcast,
-        source: normalizedSource,
-      });
-      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,
-        }),
-      };
-    },
-
-    listChatInbox({ agentId, direction = null } = {}) {
-      requireAgent(agentId);
-      const normalizedDirection = normalizeDirection(direction);
-      let requests = assertStore().listChatRequests ? assertStore().listChatRequests() : [];
-      requests = requests.filter((request) => request.fromAgentId === agentId || request.toAgentId === agentId);
-      if (normalizedDirection === 'inbound') {
-        requests = requests.filter((request) => request.toAgentId === agentId);
-      } else if (normalizedDirection === 'outbound') {
-        requests = requests.filter((request) => request.fromAgentId === agentId);
-      }
-
-      const pendingRequests = sortByRecency(
-        requests.filter((request) => request.status === 'pending'),
-        'createdAt',
-      ).map((request) => projectChatRequest(request, agentId));
-
-      const conversations = assertStore().listConversations
-        ? assertStore().listConversations({ participantId: agentId })
-        : [];
-      const chats = sortByRecency(
-        conversations
-          .map((conversation) => {
-            const linkedRequest = resolveConversationLinkRequest(requests, conversation);
-            if (!linkedRequest && !normalizeText(conversation?.meta?.approvalRequestId, null)) return null;
-            const projected = projectChatInboxChat(conversation, agentId, linkedRequest);
-            if (!projected) return null;
-            if (normalizedDirection && projected.direction !== normalizedDirection) return null;
-            return projected;
-          })
-          .filter(Boolean),
-        'lastTurnAt',
-        'updatedAt',
-        'createdAt',
-      );
-
-      return {
-        counts: {
-          pendingRequestCount: pendingRequests.length,
-          chatCount: chats.length,
-        },
-        pendingRequests,
-        chats,
-      };
-    },
-
-    listChatRequests({ agentId, direction = null } = {}) {
-      return this.listChatInbox({ agentId, direction });
-    },
-
-    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),
-      };
-    },
-
-    async rejectChatRequest(chatRequestId, { actorAgentId } = {}) {
-      requireAgent(actorAgentId);
-      const normalizedChatRequestId = normalizeText(chatRequestId, null);
-      if (!normalizedChatRequestId) {
-        throw createInvalidChatRequestError('chat_request_id_required', 'chatRequestId is required');
-      }
-
-      const result = await assertRelay('rejectChatRequest').rejectChatRequest(normalizedChatRequestId, {
-        actorAgentId,
-      });
-      if (result.status < 200 || result.status >= 300) {
-        throw createRelayResponseError(result, 'chat_request_reject_failed');
-      }
-
-      return {
-        status: 'rejected',
-        verdict: 'manual_reject',
-        chatRequest: projectChatRequest(result.body || {}, actorAgentId),
-        nextAction: 'request_rejected_by_peer',
-      };
-    },
-  };
-}