@xfxstudio/claworld 0.2.9 → 0.2.10-beta.1

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,

package/src/product-shell/worlds/world-admin-service.js

@@ -180,7 +180,7 @@ function buildWorldRecord({
   displayName,
   summary,
   worldContextText = null,
-  enabled = false,
+  enabled = true,
   status = null,
   existingMetrics = null,
 } = {}) {
@@ -246,17 +246,23 @@ function projectParticipantContextField(world = {}) {
   };
 }
 
-function projectWorldStats(store, world = {}) {
+function projectWorldStats(store, world = {}, conversationFeedbackService = null) {
   const totalParticipants = store.countMemberships({ worldId: world.worldId });
   const activeParticipants = store.countMemberships({ worldId: world.worldId, status: 'active' });
+  const feedbackSummary = conversationFeedbackService?.summarizeWorld?.({ worldId: world.worldId }) || {
+    totalLikes: 0,
+    totalDislikes: 0,
+  };
   return {
     totalParticipants,
     activeParticipants,
     totalConversationCount: Number(world.metrics?.totalConversationCount || 0),
+    totalLikes: feedbackSummary.totalLikes,
+    totalDislikes: feedbackSummary.totalDislikes,
   };
 }
 
-function projectManagedWorldSummary(store, world = {}, { worldRole = null } = {}) {
+function projectManagedWorldSummary(store, world = {}, { worldRole = null, conversationFeedbackService = null } = {}) {
   return {
     worldId: world.worldId,
     displayName: world.displayName,
@@ -267,11 +273,11 @@ function projectManagedWorldSummary(store, world = {}, { worldRole = null } = {}
     worldRole: normalizeWorldRole(worldRole, null),
     createdAt: world.createdAt || null,
     updatedAt: world.updatedAt || null,
-    stats: projectWorldStats(store, world),
+    stats: projectWorldStats(store, world, conversationFeedbackService),
   };
 }
 
-function projectManagedWorld(store, world = {}, { worldRole = null } = {}) {
+function projectManagedWorld(store, world = {}, { worldRole = null, conversationFeedbackService = null } = {}) {
   return {
     worldId: world.worldId,
     displayName: world.displayName,
@@ -284,7 +290,7 @@ function projectManagedWorld(store, world = {}, { worldRole = null } = {}) {
     createdAt: world.createdAt || null,
     updatedAt: world.updatedAt || null,
     participantContextField: projectParticipantContextField(world),
-    stats: projectWorldStats(store, world),
+    stats: projectWorldStats(store, world, conversationFeedbackService),
   };
 }
 
@@ -299,7 +305,13 @@ function buildWorldId(displayName, existingIds = []) {
   return `${base}-${counter}`;
 }
 
-export function createWorldAdminService({ worldService, worldAuthorizationService, store = null } = {}) {
+export function createWorldAdminService({
+  worldService,
+  worldAuthorizationService,
+  store = null,
+  publicIdentityService = null,
+  conversationFeedbackService = null,
+} = {}) {
   function assertStore() {
     if (!store) throw createConfigurationError();
     return store;
@@ -343,11 +355,15 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
       creatorAgentId,
       displayName,
       worldContextText,
-      enabled = false,
+      enabled = true,
       status = null,
     } = {}) {
       const storeBacked = assertStore();
       const resolvedOwnerAgentId = assertActorAgent(ownerAgentId || creatorAgentId);
+      publicIdentityService?.assertPublicIdentityReady?.({
+        agentId: resolvedOwnerAgentId,
+        capability: 'create world',
+      });
       const resolvedDisplayName = normalizeText(displayName, null);
       if (!resolvedDisplayName) throw createInvalidWorldRequestError('displayName');
       const resolvedWorldContextText = normalizeText(worldContextText, null);
@@ -360,8 +376,8 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
         displayName: resolvedDisplayName,
         summary: summarizeWorldContextText(resolvedWorldContextText, resolvedDisplayName),
         worldContextText: resolvedWorldContextText,
-        enabled: normalizeBoolean(enabled, false),
-        status: normalizeOwnerWorldStatus(status, normalizeBoolean(enabled, false) ? 'enabled' : 'draft'),
+        enabled: normalizeBoolean(enabled, true),
+        status: normalizeOwnerWorldStatus(status, normalizeBoolean(enabled, true) ? 'enabled' : 'draft'),
       });
 
       const created = await storeBacked.createWorldConfig(worldRecord);
@@ -369,6 +385,7 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
 
       return projectManagedWorld(storeBacked, normalizedWorld, {
         worldRole: WORLD_ROLES.OWNER,
+        conversationFeedbackService,
       });
     },
     listManagedWorlds({ actorAgentId, creatorAgentId, includeDisabled = true } = {}) {
@@ -383,6 +400,7 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
         }))
         .map((context) => projectManagedWorldSummary(storeBacked, context.world, {
           worldRole: context.worldRole,
+          conversationFeedbackService,
         }));
     },
     listOwnedWorlds(input = {}) {
@@ -397,6 +415,7 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
       });
       return projectManagedWorld(storeBacked, authorization.world, {
         worldRole: authorization.worldRole,
+        conversationFeedbackService,
       });
     },
     async manageWorld({ actorAgentId, creatorAgentId, worldId, changes = null, enabled = null, status = null } = {}) {
@@ -417,6 +436,7 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
       if (!hasChanges && resolvedEnabled == null && normalizedStatus == null) {
         return projectManagedWorld(storeBacked, existingWorld, {
           worldRole: authorization.worldRole,
+          conversationFeedbackService,
         });
       }
 
@@ -459,6 +479,7 @@ export function createWorldAdminService({ worldService, worldAuthorizationServic
       const normalizedWorld = worldService.requireWorld(updated.worldId, { includeDisabled: true });
       return projectManagedWorld(storeBacked, normalizedWorld, {
         worldRole: authorization.worldRole,
+        conversationFeedbackService,
       });
     },
   };

package/src/product-shell/worlds/world-broadcast-service.js

@@ -213,14 +213,14 @@ export function createWorldBroadcastService({
       const failures = [];
       for (const targetAgentId of targetAgentIds) {
         const targetAgent = store.getAgent(targetAgentId);
-        if (!targetAgent?.address) {
+        if (!targetAgent?.agentId) {
           failures.push({
             agentId: targetAgentId,
             status: 'failed',
             httpStatus: 404,
             error: 'target_not_found',
             reason: 'target_not_found',
-            message: 'target agent is missing a relay address',
+            message: 'target agent was not found',
           });
           continue;
         }

package/src/lib/agent-address.js

@@ -1,46 +0,0 @@
-const AGENT_HANDLE_SEGMENT_PATTERN = /^[A-Za-z0-9._:+~-]+$/i;
-
-function normalizeSegment(value) {
-  const normalized = String(value || '').trim().toLowerCase();
-  return normalized || null;
-}
-
-export function isValidAgentHandleSegment(value) {
-  const normalized = normalizeSegment(value);
-  return Boolean(normalized && AGENT_HANDLE_SEGMENT_PATTERN.test(normalized));
-}
-
-export function parseAgentHandle(value, { defaultDomain = null } = {}) {
-  const normalizedValue = String(value || '').trim().toLowerCase();
-  if (!normalizedValue) return null;
-
-  const firstAtIndex = normalizedValue.indexOf('@');
-  if (firstAtIndex === -1) {
-    const normalizedDomain = normalizeSegment(defaultDomain);
-    if (!isValidAgentHandleSegment(normalizedValue) || !isValidAgentHandleSegment(normalizedDomain)) {
-      return null;
-    }
-    return {
-      localPart: normalizedValue,
-      domain: normalizedDomain,
-      address: `${normalizedValue}@${normalizedDomain}`,
-      canonical: false,
-    };
-  }
-
-  if (firstAtIndex === 0 || firstAtIndex === normalizedValue.length - 1) return null;
-  if (normalizedValue.indexOf('@', firstAtIndex + 1) !== -1) return null;
-
-  const localPart = normalizeSegment(normalizedValue.slice(0, firstAtIndex));
-  const domain = normalizeSegment(normalizedValue.slice(firstAtIndex + 1));
-  if (!isValidAgentHandleSegment(localPart) || !isValidAgentHandleSegment(domain)) {
-    return null;
-  }
-
-  return {
-    localPart,
-    domain,
-    address: `${localPart}@${domain}`,
-    canonical: true,
-  };
-}