@xfxstudio/claworld 0.1.5 → 0.2.1

package/src/product-shell/contracts/chat-request-approval-policy.js

@@ -1,6 +1,6 @@
-const DEFAULT_MODE = 'manual_review';
+const DEFAULT_MODE = 'open';
 const SUPPORTED_MODES = Object.freeze([
-  DEFAULT_MODE,
+  'manual_review',
   'world_only',
   'trusted_only',
   'trusted_or_world',
@@ -45,7 +45,7 @@ export function normalizeChatRequestApprovalMode(value, fallback = DEFAULT_MODE)
     case 'manual':
     case 'manual_review':
     case 'review':
-      return DEFAULT_MODE;
+      return 'manual_review';
     case 'world':
     case 'world_only':
       return 'world_only';
@@ -88,7 +88,7 @@ export function normalizeChatRequestApprovalPolicy(
     : normalizedLegacyAutoAccept === true
       ? 'open'
       : normalizedLegacyAutoAccept === false
-        ? DEFAULT_MODE
+        ? 'manual_review'
         : normalizeChatRequestApprovalMode(fallbackMode, DEFAULT_MODE);
 
   return {

package/src/product-shell/contracts/world-manifest.js

@@ -1,5 +1,6 @@
 import { projectCandidateFeedModel } from './candidate-feed.js';
 import { buildWorldSessionStartupText } from './world-orchestration.js';
+import { buildWorldContextText } from '../worlds/world-text.js';
 
 function normalizeText(value, fallback = null) {
   if (value == null) return fallback;
@@ -96,17 +97,21 @@ function normalizeExampleSignals(exampleSignals = {}) {
 }
 
 function normalizeJoinSchema(joinSchema = {}) {
-  const requiredFields = Array.isArray(joinSchema.requiredFields)
-    ? joinSchema.requiredFields.map((field, index) => normalizeField(field, index, { required: true }))
-    : [];
-  const optionalFields = Array.isArray(joinSchema.optionalFields)
-    ? joinSchema.optionalFields.map((field, index) => normalizeField(field, index, { required: false }))
-    : [];
-
   return {
-    requiredFields,
-    optionalFields,
-    hints: normalizeStringList(joinSchema.hints),
+    requiredFields: [
+      {
+        fieldId: 'participantContextText',
+        label: 'Entry Profile',
+        type: 'string',
+        source: 'membership',
+        required: true,
+        description: 'Free-form participant profile/context text used for world join, search, and candidate review.',
+        examples: [],
+        constraints: {},
+      },
+    ],
+    optionalFields: [],
+    hints: [],
   };
 }
 
@@ -157,12 +162,25 @@ function normalizeSearchSchema(searchSchema = {}, joinSchema = {}) {
   };
 }
 
+function resolveConversationTemplateInput(manifest = {}) {
+  if (manifest.conversationTemplate && typeof manifest.conversationTemplate === 'object' && !Array.isArray(manifest.conversationTemplate)) {
+    return manifest.conversationTemplate;
+  }
+  return {};
+}
+
 export function normalizeWorldManifest(manifest = {}, index = 0) {
   const worldId = normalizeText(manifest.worldId || manifest.id, `world_${index + 1}`);
   const joinSchema = normalizeJoinSchema(manifest.joinSchema);
   const searchSchema = normalizeSearchSchema(manifest.searchSchema, joinSchema);
-  const defaultInteractionRules = normalizeText(manifest.sessionTemplate?.worldRules?.openingText, null);
-  const defaultProhibitedRules = normalizeText(manifest.sessionTemplate?.raiseHandPolicy?.summary, null);
+  const conversationTemplate = resolveConversationTemplateInput(manifest);
+  const defaultInteractionRules = normalizeText(conversationTemplate?.worldRules?.openingText, null);
+  const normalizedInteractionRules = normalizeText(manifest.interactionRules, defaultInteractionRules);
+  const normalizedProhibitedRules = normalizeText(manifest.prohibitedRules, null);
+  const normalizedRatingRules = normalizeText(
+    manifest.ratingRules,
+    'After the interaction ends, each agent should rate the other participant from 1 to 10 based on fit, clarity, and rule compliance.',
+  );
 
   return {
     worldId,
@@ -173,12 +191,21 @@ export function normalizeWorldManifest(manifest = {}, index = 0) {
     category: normalizeText(manifest.category, 'general'),
     lifecycle: normalizeText(manifest.lifecycle, 'scaffold'),
     tags: normalizeStringList(manifest.tags),
-    interactionRules: normalizeText(manifest.interactionRules, defaultInteractionRules),
-    prohibitedRules: normalizeText(manifest.prohibitedRules, defaultProhibitedRules),
-    ratingRules: normalizeText(
-      manifest.ratingRules,
-      'After the interaction ends, each agent should rate the other participant from 1 to 10 based on fit, clarity, and rule compliance.',
-    ),
+    interactionRules: normalizedInteractionRules,
+    prohibitedRules: normalizedProhibitedRules,
+    ratingRules: normalizedRatingRules,
+    worldContextText: buildWorldContextText({
+      worldId,
+      displayName: normalizeText(manifest.displayName, worldId),
+      summary: normalizeText(manifest.summary, null),
+      worldContextText: normalizeText(
+        manifest.worldContextText,
+        normalizeText(manifest.runtimeWorldContext?.text, null),
+      ),
+      interactionRules: normalizedInteractionRules,
+      prohibitedRules: normalizedProhibitedRules,
+      ratingRules: normalizedRatingRules,
+    }),
     creatorAgentId: normalizeText(manifest.creatorAgentId, null),
     adminAgentIds: normalizeStringList(manifest.adminAgentIds),
     eligibility: normalizeWorldEligibility(manifest.eligibility, 'active'),
@@ -208,25 +235,15 @@ export function normalizeWorldManifest(manifest = {}, index = 0) {
       strategySummary: normalizeText(manifest.matching?.strategySummary, null),
       candidateSources: normalizeCandidateSources(manifest.matching?.candidateSources),
     },
-    sessionTemplate: {
-      mode: normalizeText(manifest.sessionTemplate?.mode, 'a2a'),
-      maxTurns: Number.isFinite(Number(manifest.sessionTemplate?.maxTurns))
-        ? Math.max(1, Number(manifest.sessionTemplate.maxTurns))
-        : 6,
-      turnTimeoutMs: Number.isFinite(Number(manifest.sessionTemplate?.turnTimeoutMs))
-        ? Math.max(1000, Number(manifest.sessionTemplate.turnTimeoutMs))
-        : 60_000,
-      raiseHandPolicy: {
-        mode: normalizeText(manifest.sessionTemplate?.raiseHandPolicy?.mode, 'dual_raise_hand'),
-        summary: normalizeText(manifest.sessionTemplate?.raiseHandPolicy?.summary, null),
-      },
+    conversationTemplate: {
+      mode: normalizeText(conversationTemplate?.mode, 'a2a'),
       worldRules: {
-        openingText: normalizeText(manifest.sessionTemplate?.worldRules?.openingText, null),
-        turnMessageRules: Array.isArray(manifest.sessionTemplate?.worldRules?.turnMessageRules)
-          ? manifest.sessionTemplate.worldRules.turnMessageRules
+        openingText: normalizeText(conversationTemplate?.worldRules?.openingText, null),
+        turnMessageRules: Array.isArray(conversationTemplate?.worldRules?.turnMessageRules)
+          ? conversationTemplate.worldRules.turnMessageRules
           : [],
-        convergence: manifest.sessionTemplate?.worldRules?.convergence || {},
-        stateChangeMessages: manifest.sessionTemplate?.worldRules?.stateChangeMessages || {},
+        convergence: conversationTemplate?.worldRules?.convergence || {},
+        stateChangeMessages: conversationTemplate?.worldRules?.stateChangeMessages || {},
       },
     },
     resultContract: {
@@ -243,40 +260,26 @@ export function normalizeWorldManifest(manifest = {}, index = 0) {
 }
 
 export function projectWorldCard(world) {
-  const agentSummary = {
-    displayName: world.displayName,
-    summary: world.summary,
-    category: world.category,
-    requiredFieldCount: world.joinSchema.requiredFields.length,
-    matchingMode: world.matching.mode,
-    sessionMode: world.sessionTemplate.mode,
-  };
-
   return {
     worldId: world.worldId,
     slug: world.slug,
-    displayName: agentSummary.displayName,
-    summary: agentSummary.summary,
-    category: agentSummary.category,
-    lifecycle: world.lifecycle,
-    tags: world.tags,
-    requiredFieldCount: agentSummary.requiredFieldCount,
-    roleCount: world.roles.length,
-    matchingMode: agentSummary.matchingMode,
-    sessionMode: agentSummary.sessionMode,
+    displayName: world.displayName,
+    worldContextText: world.worldContextText,
     createdAt: world.createdAt || null,
     updatedAt: world.updatedAt || null,
-    status: world.meta.status,
-    agentSummary,
+    status: world.status || world.meta.status,
+    enabled: world.enabled === true,
   };
 }
 
 export function projectJoinPlan(world) {
   return {
     worldId: world.worldId,
-    requiredFields: world.joinSchema.requiredFields,
-    optionalFields: world.joinSchema.optionalFields,
-    hints: world.joinSchema.hints,
+    participantContextField: {
+      fieldId: 'participantContextText',
+      label: 'Entry Profile',
+      description: 'A short text describing who you are in this world and what context you bring into it.',
+    },
     nextAction: 'call_join_world',
   };
 }
@@ -314,140 +317,92 @@ export function projectSearchModel(world) {
 
 export function projectWorldDetail(world) {
   const joinPlan = projectJoinPlan(world);
-  const requiredFieldGuide = projectFieldGuide(world.joinSchema.requiredFields, { required: true });
-  const optionalFieldGuide = projectFieldGuide(world.joinSchema.optionalFields, { required: false });
-  const allFieldGuide = [...requiredFieldGuide, ...optionalFieldGuide];
-  const candidateFeedOverview = projectCandidateFeedModel(world);
-  const searchSchema = projectSearchModel(world);
-  const runtimeStartupContext = {
-    worldId: world.worldId,
-    status: 'ready',
-    source: 'product_shell_session_startup',
-    text: buildWorldSessionStartupText({
+  const worldContextText = normalizeText(
+    world.worldContextText,
+    buildWorldSessionStartupText({
       worldId: world.worldId,
       displayName: world.displayName,
       summary: world.summary,
       interactionRules: world.interactionRules,
       prohibitedRules: world.prohibitedRules,
       ratingRules: world.ratingRules,
-      sessionMode: world.sessionTemplate.mode,
-      sessionOverview: {
+      conversationMode: world.conversationTemplate.mode,
+      conversationOverview: {
         worldId: world.worldId,
-        mode: world.sessionTemplate.mode,
-        maxTurns: world.sessionTemplate.maxTurns,
-        turnTimeoutMs: world.sessionTemplate.turnTimeoutMs,
-        raiseHandPolicy: world.sessionTemplate.raiseHandPolicy,
-        openingText: world.sessionTemplate.worldRules.openingText,
-        convergence: world.sessionTemplate.worldRules.convergence,
+        mode: world.conversationTemplate.mode,
+        openingText: world.conversationTemplate.worldRules.openingText,
+        convergence: world.conversationTemplate.worldRules.convergence,
       },
     }),
-  };
+  );
 
   return {
-    world: world,
-    agentSummary: {
-      displayName: world.displayName,
-      summary: world.summary,
-      category: world.category,
-      requiredFieldCount: world.joinSchema.requiredFields.length,
-      optionalFieldCount: world.joinSchema.optionalFields.length,
-      matchingMode: world.matching.mode,
-      sessionMode: world.sessionTemplate.mode,
-    },
-    joinSchema: {
-      worldId: world.worldId,
-      requiredFields: world.joinSchema.requiredFields,
-      optionalFields: world.joinSchema.optionalFields,
-      requiredFieldIds: requiredFieldGuide.map((field) => field.fieldId),
-      optionalFieldIds: optionalFieldGuide.map((field) => field.fieldId),
-      requiredFieldCount: requiredFieldGuide.length,
-      optionalFieldCount: optionalFieldGuide.length,
-      hints: world.joinSchema.hints,
-      nextAction: joinPlan.nextAction,
-    },
-    fieldGuide: {
-      required: requiredFieldGuide,
-      optional: optionalFieldGuide,
-      allFields: allFieldGuide,
-    },
-    sessionOverview: {
+    worldId: world.worldId,
+    world: {
       worldId: world.worldId,
-      mode: world.sessionTemplate.mode,
-      maxTurns: world.sessionTemplate.maxTurns,
-      turnTimeoutMs: world.sessionTemplate.turnTimeoutMs,
-      raiseHandPolicy: world.sessionTemplate.raiseHandPolicy,
-      openingText: world.sessionTemplate.worldRules.openingText,
-      convergence: world.sessionTemplate.worldRules.convergence,
-      turnMessageRules: world.sessionTemplate.worldRules.turnMessageRules,
-      expectationSummary:
-        `Expect a ${world.sessionTemplate.mode} session with up to ${world.sessionTemplate.maxTurns} turns and ` +
-        `a ${world.sessionTemplate.turnTimeoutMs}ms turn timeout before the world asks both agents to converge.`,
-      status: 'scaffold_ready',
+      displayName: world.displayName,
+      worldContextText,
     },
-    matchingOverview: {
-      worldId: world.worldId,
-      mode: world.matching.mode,
-      cadence: world.matching.cadence,
-      strategySummary: world.matching.strategySummary,
-      candidateSources: world.matching.candidateSources,
-      inputFields: requiredFieldGuide.map((field) => field.fieldId),
-      optionalContextFields: optionalFieldGuide.map((field) => field.fieldId),
-      searchMode: searchSchema.mode,
-      deliveryMode: candidateFeedOverview.deliveryMode,
-      status: 'scaffold_ready',
+    management: {
+      ownerAgentId: world.creatorAgentId || null,
+      enabled: world.enabled === true,
+      status: world.status || world.meta.status,
+      createdAt: world.createdAt || null,
+      updatedAt: world.updatedAt || null,
+      memberCount: world.metrics?.memberCount || null,
+      totalConversationCount: Number.isFinite(Number(world.metrics?.totalConversationCount))
+        ? Math.max(0, Math.trunc(Number(world.metrics.totalConversationCount)))
+        : 0,
     },
-    searchSchema,
-    candidateFeedOverview,
+    participantContextField: joinPlan.participantContextField,
     joinPlan,
-    runtimeStartupContext,
+    worldContextText,
   };
 }
 
-export function projectSessionStartupContext(world) {
-  const runtimeStartupContext = {
+export function projectConversationWorldContext(world) {
+  const runtimeWorldContext = {
     worldId: world.worldId,
     status: 'ready',
-    source: 'product_shell_session_startup',
-    text: buildWorldSessionStartupText({
-      worldId: world.worldId,
-      displayName: world.displayName,
-      summary: world.summary,
-      interactionRules: world.interactionRules,
-      prohibitedRules: world.prohibitedRules,
-      ratingRules: world.ratingRules,
-      sessionMode: world.sessionTemplate.mode,
-      sessionOverview: {
+    source: 'product_shell_conversation_world_context',
+    text: normalizeText(
+      world.worldContextText,
+      buildWorldSessionStartupText({
         worldId: world.worldId,
-        mode: world.sessionTemplate.mode,
-        maxTurns: world.sessionTemplate.maxTurns,
-        turnTimeoutMs: world.sessionTemplate.turnTimeoutMs,
-        raiseHandPolicy: world.sessionTemplate.raiseHandPolicy,
-        openingText: world.sessionTemplate.worldRules.openingText,
-        convergence: world.sessionTemplate.worldRules.convergence,
-      },
-    }),
+        displayName: world.displayName,
+        summary: world.summary,
+        interactionRules: world.interactionRules,
+        prohibitedRules: world.prohibitedRules,
+        ratingRules: world.ratingRules,
+        conversationMode: world.conversationTemplate.mode,
+        conversationOverview: {
+          worldId: world.worldId,
+          mode: world.conversationTemplate.mode,
+          openingText: world.conversationTemplate.worldRules.openingText,
+          convergence: world.conversationTemplate.worldRules.convergence,
+        },
+      }),
+    ),
   };
 
   return {
     worldId: world.worldId,
     displayName: world.displayName,
     summary: world.summary,
+    worldContextText: runtimeWorldContext.text,
     interactionRules: world.interactionRules,
     prohibitedRules: world.prohibitedRules,
     ratingRules: world.ratingRules,
-    sessionMode: world.sessionTemplate.mode,
-    sessionOverview: {
+    conversationMode: world.conversationTemplate.mode,
+    conversationOverview: {
       worldId: world.worldId,
-      mode: world.sessionTemplate.mode,
-      maxTurns: world.sessionTemplate.maxTurns,
-      turnTimeoutMs: world.sessionTemplate.turnTimeoutMs,
-      raiseHandPolicy: world.sessionTemplate.raiseHandPolicy,
-      openingText: world.sessionTemplate.worldRules.openingText,
-      convergence: world.sessionTemplate.worldRules.convergence,
-      turnMessageRules: world.sessionTemplate.worldRules.turnMessageRules,
+      mode: world.conversationTemplate.mode,
+      openingText: world.conversationTemplate.worldRules.openingText,
+      convergence: world.conversationTemplate.worldRules.convergence,
+      turnMessageRules: world.conversationTemplate.worldRules.turnMessageRules,
     },
     status: 'ready',
-    source: 'product_shell_session_startup',
-    runtimeStartupContext,
+    source: 'product_shell_conversation_world_context',
+    runtimeWorldContext,
   };
 }