@xfxstudio/claworld 0.2.8 → 0.2.10-beta.0

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

@@ -1,4 +1,6 @@
 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';
@@ -66,7 +68,7 @@ function createAgentNotFoundError(agentId) {
   return error;
 }
 
-function createTargetAddressNotFoundError(targetAgentId) {
+function createTargetAgentNotFoundError(targetAgentId) {
   const error = new Error(`chat_request_target_not_found:${targetAgentId}`);
   error.code = 'chat_request_target_not_found';
   error.status = 404;
@@ -123,10 +125,8 @@ function projectAgent(store, agentId, presence = null) {
   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),
+    publicIdentity: resolvePublicIdentity(agent),
     profile: normalizeAgentProfile(agent.profile),
     discoverable: visibility.discoverable,
     contactable: visibility.contactable,
@@ -281,12 +281,100 @@ function projectChatRequestOrigin(request = {}) {
   };
 }
 
+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');
@@ -350,8 +438,37 @@ export function createChatRequestService({
     };
   }
 
+  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,
@@ -389,39 +506,51 @@ export function createChatRequestService({
       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 normalizedWorldId = normalizeConversationWorldId(worldId);
-      if (!targetAgent?.address) {
-        throw createTargetAddressNotFoundError(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);
+      const normalizedOpeningPayload = cloneJsonObject(openingPayload) || cloneJsonObject(normalizedRequestInput.openingPayload);
       const normalizedKickoffBrief = createKickoffBrief({
         text: typeof kickoffBrief === 'object' && kickoffBrief !== null && !Array.isArray(kickoffBrief)
           ? kickoffBrief.text
-          : openingMessage,
+          : 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
-          : source === 'world_broadcast'
+          : normalizedSource === 'world_broadcast'
             ? 'world_broadcast_brief'
             : 'chat_request_brief',
       });
-      const normalizedOrigin = normalizeChatRequestOrigin(origin);
-      const normalizedBroadcast = normalizeChatRequestBroadcastMetadata(broadcast);
+      const normalizedOrigin = normalizeChatRequestOrigin(origin) || normalizeChatRequestOrigin(normalizedRequestInput.origin);
+      const normalizedBroadcast = normalizeChatRequestBroadcastMetadata(broadcast)
+        || normalizeChatRequestBroadcastMetadata(normalizedRequestInput.broadcast);
       if (normalizedWorldId) {
         worldService?.requireWorld?.(normalizedWorldId);
-        if (normalizeText(source, 'chat_request') !== 'world_broadcast') {
+        if (normalizedSource !== 'world_broadcast') {
           const authorization = worldAuthorizationService.evaluateWorldAction({
             worldId: normalizedWorldId,
             actorAgentId: fromAgentId,
@@ -435,7 +564,7 @@ export function createChatRequestService({
 
       const result = await assertRelay('createChatRequest').createChatRequest({
         fromAgentId,
-        toAddress: targetAgent.address,
+        targetAgentId: targetAgent.agentId,
         kickoffBrief: normalizedKickoffBrief,
         openingMessage: normalizeText(
           normalizedKickoffBrief?.text,
@@ -445,9 +574,10 @@ export function createChatRequestService({
         conversation: {
           ...(normalizedWorldId ? { worldId: normalizedWorldId } : {}),
         },
+        requestContext: cloneJsonObject(requestContext),
         origin: normalizedOrigin,
         broadcast: normalizedBroadcast,
-        source: normalizeText(source, 'chat_request'),
+        source: normalizedSource,
       });
       if (result.status < 200 || result.status >= 300) {
         throw createRelayResponseError(result, 'chat_request_create_failed');
@@ -495,23 +625,55 @@ export function createChatRequestService({
       };
     },
 
-    listChatRequests({ agentId, direction = null } = {}) {
+    listChatInbox({ 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);
+      let requests = assertStore().listChatRequests ? assertStore().listChatRequests() : [];
+      requests = requests.filter((request) => request.fromAgentId === agentId || request.toAgentId === agentId);
       if (normalizedDirection === 'inbound') {
-        items = items.filter((request) => request.toAgentId === agentId);
+        requests = requests.filter((request) => request.toAgentId === agentId);
       } else if (normalizedDirection === 'outbound') {
-        items = items.filter((request) => request.fromAgentId === agentId);
+        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 {
-        items: sortByRecency(items, 'createdAt').map((request) => projectChatRequest(request, agentId)),
+        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);

package/src/product-shell/social/friend-routes.js

@@ -12,7 +12,7 @@ export function registerFriendRoutes(app, { friendService }) {
     try {
       const result = await friendService.createFriendRequest({
         fromAgentId: req.body?.fromAgentId,
-        toAddress: req.body?.toAddress,
+        targetAgentId: req.body?.targetAgentId,
         message: req.body?.message,
         metadata: req.body?.metadata,
       });

package/src/product-shell/social/friend-service.js

@@ -1,16 +1,12 @@
 import { normalizeAgentProfile, resolveAgentDisplayName, resolveAgentVisibility } from '../../lib/agent-profile.js';
 import { createRelayPolicyHooks, evaluatePolicyHook } from '../../lib/policy.js';
+import { resolvePublicIdentity } from '../../lib/public-identity.js';
 
 function normalizeAgentId(agentId) {
   const normalized = String(agentId || '').trim();
   return normalized || null;
 }
 
-function normalizeAddress(address) {
-  const normalized = String(address || '').trim().toLowerCase();
-  return normalized || null;
-}
-
 function normalizeDirection(direction) {
   const normalized = String(direction || '').trim().toLowerCase();
   return normalized === 'inbound' || normalized === 'outbound' ? normalized : null;
@@ -54,8 +50,8 @@ function createAgentNotFoundError(agentId) {
   return error;
 }
 
-function createTargetNotFoundError(address) {
-  const error = new Error(`friend_target_not_found:${address}`);
+function createTargetNotFoundError(targetAgentId) {
+  const error = new Error(`friend_target_not_found:${targetAgentId}`);
   error.code = 'friend_target_not_found';
   error.status = 404;
   return error;
@@ -131,10 +127,8 @@ function projectAgent(store, agentId) {
   const visibility = resolveAgentVisibility(agent);
   return {
     agentId: agent.agentId,
-    agentCode: agent.agentCode,
-    domain: agent.domain,
-    address: agent.address,
     displayName: resolveAgentDisplayName(agent),
+    publicIdentity: resolvePublicIdentity(agent),
     profile: normalizeAgentProfile(agent.profile),
     discoverable: visibility.discoverable,
     contactable: visibility.contactable,
@@ -149,7 +143,7 @@ function resolvePeerAgentId(friendship, viewerAgentId) {
   return null;
 }
 
-export function createFriendService({ store = null, policy = null } = {}) {
+export function createFriendService({ store = null, policy = null, publicIdentityService = null } = {}) {
   const relayPolicy = createRelayPolicyHooks(policy);
 
   function assertStore() {
@@ -307,23 +301,27 @@ export function createFriendService({ store = null, policy = null } = {}) {
   }
 
   return {
-    async createFriendRequest({ fromAgentId, toAddress, message = null, metadata = {} } = {}) {
+    async createFriendRequest({ fromAgentId, targetAgentId, message = null, metadata = {} } = {}) {
       const friendshipStore = assertStore();
       const fromAgent = requireAgent(fromAgentId);
-      const normalizedToAddress = normalizeAddress(toAddress);
-      if (!normalizedToAddress) {
-        throw createTargetNotFoundError(toAddress);
+      publicIdentityService?.assertPublicIdentityReady?.({
+        agentId: fromAgent.agentId,
+        capability: 'send friend request',
+      });
+      const normalizedTargetAgentId = normalizeAgentId(targetAgentId);
+      if (!normalizedTargetAgentId) {
+        throw createTargetNotFoundError(targetAgentId);
       }
 
-      const toAgent = friendshipStore.resolveAddress(normalizedToAddress);
-      if (!toAgent) throw createTargetNotFoundError(normalizedToAddress);
+      const toAgent = friendshipStore.getAgent(normalizedTargetAgentId);
+      if (!toAgent) throw createTargetNotFoundError(normalizedTargetAgentId);
 
       const canRequest = evaluatePolicyHook({
         hook: relayPolicy.canRequest,
         context: {
           fromAgentId: fromAgent.agentId,
           fromAgent,
-          toAddress: normalizedToAddress,
+          targetAgentId: normalizedTargetAgentId,
           toAgent,
           requestContext: {
             type: 'friend_request',
@@ -382,7 +380,6 @@ export function createFriendService({ store = null, policy = null } = {}) {
       const request = await friendshipStore.createFriendRequest({
         fromAgentId: fromAgent.agentId,
         toAgentId: toAgent.agentId,
-        toAddress: toAgent.address,
         message: normalizeMessage(message),
         metadata,
       });

package/src/product-shell/social/social-routes.js

@@ -10,8 +10,8 @@ function sendSocialError(res, error) {
 export function registerSocialRoutes(app, { socialService }) {
   app.get('/v1/social/agents/lookup', (req, res) => {
     try {
-      const result = socialService.lookupAgentByCode({
-        agentCode: req.query.agentCode,
+      const result = socialService.lookupAgentByIdentity({
+        identity: req.query.identity,
       });
       res.json(result);
     } catch (error) {

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

@@ -3,7 +3,7 @@ import {
   resolveAgentDisplayName,
   resolveAgentVisibility,
 } from '../../lib/agent-profile.js';
-import { parseAgentHandle } from '../../lib/agent-address.js';
+import { parsePublicIdentityDisplay, resolvePublicIdentity } from '../../lib/public-identity.js';
 
 function normalizeText(value, fallback = null) {
   if (value == null) return fallback;
@@ -11,18 +11,6 @@ function normalizeText(value, fallback = null) {
   return normalized || fallback;
 }
 
-function parseCanonicalAgentCode(value) {
-  const parsed = parseAgentHandle(value);
-  if (!parsed?.canonical) return null;
-
-  return {
-    agentCode: parsed.address,
-    relayLocalCode: parsed.localPart,
-    domain: parsed.domain,
-    address: parsed.address,
-  };
-}
-
 function createConfigurationError() {
   const error = new Error('social_lookup_store_unavailable');
   error.code = 'social_lookup_store_unavailable';
@@ -30,44 +18,44 @@ function createConfigurationError() {
   return error;
 }
 
-function createInvalidAgentCodeError(agentCode) {
-  const error = new Error('invalid_agent_code');
-  error.code = 'invalid_agent_code';
+function createInvalidPublicIdentityError(identity) {
+  const error = new Error('invalid_public_identity');
+  error.code = 'invalid_public_identity';
   error.status = 400;
   error.responseBody = {
     error: error.code,
-    message: 'agentCode must use canonical local@namespace schema',
-    agentCode: normalizeText(agentCode, null),
+    message: 'identity must use displayName#code',
+    identity: normalizeText(identity, null),
     fieldErrors: [
       {
-        fieldId: 'agentCode',
-        message: 'agentCode must use canonical local@namespace schema',
+        fieldId: 'identity',
+        message: 'identity must use displayName#code',
       },
     ],
   };
   return error;
 }
 
-function createAgentNotFoundError(agentCode) {
-  const error = new Error(`agent_not_found:${agentCode}`);
+function createAgentNotFoundError(identity) {
+  const error = new Error(`agent_not_found:${identity}`);
   error.code = 'agent_not_found';
   error.status = 404;
   error.responseBody = {
     error: error.code,
-    message: 'no agent found for canonical agentCode',
-    agentCode,
+    message: 'no agent found for public identity',
+    identity,
   };
   return error;
 }
 
-function createNotDiscoverableError(agentCode) {
-  const error = new Error(`not_discoverable:${agentCode}`);
+function createNotDiscoverableError(identity) {
+  const error = new Error(`not_discoverable:${identity}`);
   error.code = 'not_discoverable';
   error.status = 403;
   error.responseBody = {
     error: error.code,
     message: 'agent is not discoverable',
-    agentCode,
+    identity,
   };
   return error;
 }
@@ -94,21 +82,27 @@ export function createSocialService({ worldService, store = null } = {}) {
   }
 
   return {
-    lookupAgentByCode({ agentCode } = {}) {
+    lookupAgentByIdentity({ identity } = {}) {
       const socialStore = assertStore();
-      const parsedAgentCode = parseCanonicalAgentCode(agentCode);
-      if (!parsedAgentCode) {
-        throw createInvalidAgentCodeError(agentCode);
+      const parsedIdentity = parsePublicIdentityDisplay(identity);
+      if (!parsedIdentity) {
+        throw createInvalidPublicIdentityError(identity);
       }
 
-      const agent = socialStore.resolveAddress(parsedAgentCode.address);
+      const agent = socialStore
+        .listAgents()
+        .find((candidate) => {
+          const candidateIdentity = resolvePublicIdentity(candidate);
+          return candidateIdentity.status === 'ready'
+            && candidateIdentity.code === parsedIdentity.code;
+        }) || null;
       if (!agent) {
-        throw createAgentNotFoundError(parsedAgentCode.agentCode);
+        throw createAgentNotFoundError(parsedIdentity.identity);
       }
 
       const visibility = resolveAgentVisibility(agent);
       if (!visibility.discoverable) {
-        throw createNotDiscoverableError(parsedAgentCode.agentCode);
+        throw createNotDiscoverableError(parsedIdentity.identity);
       }
 
       const activeWorlds = socialStore
@@ -124,8 +118,10 @@ export function createSocialService({ worldService, store = null } = {}) {
       return {
         status: 'found',
         publicProfile: {
-          agentCode: agent.address || parsedAgentCode.agentCode,
+          agentId: agent.agentId,
+          identity: resolvePublicIdentity(agent).displayIdentity || parsedIdentity.identity,
           displayName: resolveAgentDisplayName(agent),
+          code: resolvePublicIdentity(agent).code,
           profile: normalizeAgentProfile(agent.profile),
           discoverable: visibility.discoverable,
           contactable: visibility.contactable,