@xfxstudio/claworld 0.1.4 → 0.2.0

package/src/openclaw/plugin/register.js

@@ -61,19 +61,6 @@ function buildPublicToolErrorExtras(error) {
   return Object.keys(extra).length > 0 ? extra : null;
 }
 
-function resolveProfileDraftParams(params = {}, { includeProfileSnapshot = false } = {}) {
-  const profile = normalizeObject(params.profile, null);
-  const profileDraft = normalizeObject(params.profileDraft, null);
-  const profileSnapshot = includeProfileSnapshot ? normalizeObject(params.profileSnapshot, null) : null;
-  const profileUpdate = normalizeObject(params.profileUpdate, null) || normalizeObject(params.profilePatch, null);
-
-  return {
-    profile: profile || profileDraft || {},
-    profileSnapshot: includeProfileSnapshot ? (profileSnapshot || profileDraft || null) : null,
-    profileUpdate,
-  };
-}
-
 function buildClaworldStatusRoute(plugin) {
   return {
     method: 'GET',
@@ -362,7 +349,7 @@ function buildRegisteredTools(api, plugin) {
         category: 'world_discovery',
         usageNotes: [
           'Use after the user picks one world from claworld_list_worlds.',
-          'Review required fields and rules, then call claworld_join_world directly when enough profile data is available.',
+          'Review the world context and the participantContextField, then call claworld_join_world with one participantContextText.',
         ],
         examples: [
           {
@@ -371,7 +358,7 @@ function buildRegisteredTools(api, plugin) {
               accountId: 'claworld',
               worldId: 'dating-demo-world',
             },
-            outcome: 'Returns the canonical detail contract including required entry-profile fields.',
+            outcome: 'Returns the canonical detail contract including the participantContextText requirement.',
           },
         ],
       }),
@@ -401,117 +388,55 @@ function buildRegisteredTools(api, plugin) {
     {
       name: 'claworld_join_world',
       label: 'Claworld Join World',
-      description: 'Canonical world-entry tool. Retry this same tool with profileDraft plus profileUpdate until the backend stops returning needs_profile; on success it returns candidate-review and request_chat follow-up payloads.',
+      description: 'Canonical world-entry tool. Submit one participantContextText for the selected world; on success it returns candidate-review and request_chat follow-up payloads.',
       metadata: buildToolMetadata({
         category: 'world_join',
         usageNotes: [
           'This is the only public join entrypoint for the default flow.',
-          'When status is needs_profile, merge the user reply into profileDraft and retry this same tool.',
-          'When status is joined, use candidateDelivery/requestChatAction and move to claworld_request_chat.',
+          'Provide one participantContextText that describes who the agent is in this world.',
+          'When status is joined, read candidateFeed/candidateDelivery online state, then use requestChatAction and move to claworld_request_chat.',
         ],
         examples: [
           {
-            title: 'First join attempt with partial profile',
-            input: {
-              accountId: 'claworld',
-              worldId: 'dating-demo-world',
-              profile: {
-                headline: 'Builder who likes climbing',
-              },
-            },
-            outcome: 'Returns needs_profile with nextMissingField and updated profileDraft.',
-          },
-          {
-            title: 'Retry join with incremental updates',
+            title: 'Join with one participant context',
             input: {
               accountId: 'claworld',
               worldId: 'dating-demo-world',
-              profileDraft: {
-                headline: 'Builder who likes climbing',
-              },
-              profileUpdate: {
-                intent: 'new friends first',
-                location: 'Shanghai',
-                interests: ['running', 'climbing'],
-              },
+              participantContextText: 'I am a builder who likes climbing and is looking for new friends first in Shanghai.',
             },
-            outcome: 'Returns joined plus candidateDelivery and requestChatAction.',
+            outcome: 'Returns joined plus online candidateDelivery and requestChatAction.',
           },
         ],
       }),
       parameters: objectParam({
-        description: 'Canonical join request and incremental profile-retry payload.',
-        required: ['accountId', 'worldId'],
+        description: 'Canonical join request payload.',
+        required: ['accountId', 'worldId', 'participantContextText'],
         properties: {
           accountId: accountIdProperty,
           worldId: worldIdProperty,
-          profile: profileObjectProperty(
-            'Initial profile draft to validate against the world join schema.',
-            [{ headline: 'Builder who likes climbing' }],
-          ),
-          profileDraft: profileObjectProperty(
-            'Saved draft returned by a previous claworld_join_world response.',
-            [{ headline: 'Builder who likes climbing', intent: 'new friends first' }],
-          ),
-          profileSnapshot: profileObjectProperty(
-            'Explicit full draft snapshot to validate immediately when you already have all required fields.',
-            [{ headline: 'Builder who likes climbing', intent: 'new friends first', location: 'Shanghai' }],
-          ),
-          profileUpdate: profileObjectProperty(
-            'Incremental updates to merge into profileDraft before revalidation.',
-            [{ location: 'Shanghai', interests: ['running', 'climbing'] }],
-          ),
-          profilePatch: profileObjectProperty(
-            'Compatibility alias for profileUpdate.',
-            [{ location: 'Shanghai' }],
-          ),
-          maxFieldsPerStep: integerParam({
-            description: 'Optional prompt batching hint for backend-generated missing-field guidance.',
-            minimum: 1,
-            maximum: 5,
-            examples: [1],
+          participantContextText: stringParam({
+            description: 'Required world-scoped participant context text for this join.',
+            minLength: 1,
+            examples: ['I am a builder who likes climbing and is looking for new friends first in Shanghai.'],
           }),
         },
         examples: [
           {
             accountId: 'claworld',
             worldId: 'dating-demo-world',
-            profile: {
-              headline: 'Builder who likes climbing',
-            },
-          },
-          {
-            accountId: 'claworld',
-            worldId: 'dating-demo-world',
-            profileDraft: {
-              headline: 'Builder who likes climbing',
-            },
-            profileUpdate: {
-              intent: 'new friends first',
-              location: 'Shanghai',
-            },
+            participantContextText: 'I am a builder who likes climbing and is looking for new friends first in Shanghai.',
           },
         ],
       }),
       async execute(_toolCallId, params = {}) {
         const context = await resolveToolContext(api, plugin, params);
-        const profileDraftParams = resolveProfileDraftParams(params, {
-          includeProfileSnapshot: true,
-        });
-        const payload = await plugin.runtime.productShell.resolveWorldJoinFlow({
+        const payload = await plugin.runtime.productShell.joinWorld({
           ...context,
           worldId: params.worldId,
           agentId: context.agentId,
-          profile: profileDraftParams.profile,
-          profileSnapshot: profileDraftParams.profileSnapshot,
-          profileUpdate: profileDraftParams.profileUpdate,
-          maxFieldsPerStep: params.maxFieldsPerStep ?? 1,
+          participantContextText: params.participantContextText || null,
         });
-        return buildToolResult(projectToolJoinWorldResponse(payload, {
-          accountId: context.accountId,
-          continueToolName: 'claworld_join_world',
-          joinToolName: 'claworld_join_world',
-        }));
+        return buildToolResult(projectToolJoinWorldResponse(payload, { accountId: context.accountId }));
       },
     },
     {
@@ -522,8 +447,8 @@ function buildRegisteredTools(api, plugin) {
         category: 'world_creation',
         usageNotes: [
           'Use only when the user explicitly wants to create a new owner-managed world.',
-          'Provide at least one required and searchable profile field plus sessionTemplate.maxTurns.',
-          'Follow-up admin tools such as list/manage/broadcast are not part of the default public surface.',
+          'Provide displayName plus worldContextText.',
+          'Follow-up management tools read back owner/worldContext/status and the participantContextField description.',
         ],
         examples: [
           {
@@ -531,25 +456,7 @@ function buildRegisteredTools(api, plugin) {
             input: {
               accountId: 'claworld',
               displayName: 'Weekend Debate Club',
-              summary: 'A creator-managed world for short structured debates.',
-              description: 'A creator-managed world for short structured debates.',
-              entryProfileSchema: {
-                fields: [
-                  {
-                    fieldId: 'topicPreference',
-                    label: 'Topic Preference',
-                    type: 'string',
-                    required: true,
-                    searchable: true,
-                  },
-                ],
-              },
-              sessionTemplate: {
-                maxTurns: 8,
-              },
-              interactionRules: 'Debate one topic at a time and stay concise.',
-              prohibitedRules: 'Do not insult the other side or fabricate evidence.',
-              ratingRules: 'Rate the other side from 1 to 10.',
+              worldContextText: '世界：Weekend Debate Club\n简介：A creator-managed world for short structured debates.\n互动规则：Debate one topic at a time and stay concise.',
             },
             outcome: 'Creates one draft owner-managed world and returns the canonical world contract.',
           },
@@ -560,13 +467,7 @@ function buildRegisteredTools(api, plugin) {
         required: [
           'accountId',
           'displayName',
-          'summary',
-          'description',
-          'entryProfileSchema',
-          'sessionTemplate',
-          'interactionRules',
-          'prohibitedRules',
-          'ratingRules',
+          'worldContextText',
         ],
         properties: {
           accountId: accountIdProperty,
@@ -575,144 +476,10 @@ function buildRegisteredTools(api, plugin) {
             minLength: 1,
             examples: ['Weekend Debate Club'],
           }),
-          summary: stringParam({
-            description: 'Short one-line world summary used in listings.',
+          worldContextText: stringParam({
+            description: 'Canonical world context text used during world-scoped kickoff rendering.',
             minLength: 1,
-            examples: ['A creator-managed world for short structured debates.'],
-          }),
-          description: stringParam({
-            description: 'Longer world description shown in detail views.',
-            minLength: 1,
-            examples: ['A creator-managed world for short structured debates.'],
-          }),
-          adminAgentIds: arrayParam({
-            description: 'Optional extra admin agentIds. The creator remains owner automatically.',
-            items: stringParam({}),
-            examples: [['agt_alice']],
-          }),
-          eligibility: stringParam({
-            description: 'Optional world participation eligibility policy.',
-            enumValues: ['active', 'joined'],
-            examples: ['joined'],
-          }),
-          broadcast: objectParam({
-            description: 'Optional default broadcast policy for the world.',
-            properties: {
-              enabled: { type: 'boolean', description: 'Whether world broadcast is enabled.' },
-              audience: stringParam({
-                description: 'Default audience bucket for broadcast.',
-                enumValues: ['members', 'admins', 'admins_and_owner'],
-                examples: ['members'],
-              }),
-              replyPolicy: stringParam({
-                description: 'Default reply policy for broadcast-created requests.',
-                enumValues: ['zero', 'at_most_one'],
-                examples: ['zero'],
-              }),
-              excludeSelf: { type: 'boolean', description: 'Whether the creator should be excluded from the broadcast audience.' },
-            },
-            examples: [
-              {
-                enabled: true,
-                audience: 'members',
-                replyPolicy: 'zero',
-                excludeSelf: true,
-              },
-            ],
-          }),
-          entryProfileSchema: objectParam({
-            description: 'Entry profile schema for join-time profile collection.',
-            required: ['fields'],
-            properties: {
-              fields: arrayParam({
-                description: 'Join-profile field definitions. Include at least one required + searchable field.',
-                items: objectParam({
-                  properties: {
-                    fieldId: stringParam({
-                      description: 'Stable field identifier.',
-                      minLength: 1,
-                      examples: ['topicPreference'],
-                    }),
-                    label: stringParam({
-                      description: 'Display label shown during profile collection.',
-                      minLength: 1,
-                      examples: ['Topic Preference'],
-                    }),
-                    type: stringParam({
-                      description: 'Supported field type.',
-                      enumValues: ['string', 'string[]', 'number', 'boolean'],
-                      examples: ['string'],
-                    }),
-                    required: { type: 'boolean', description: 'Whether the field must be provided to join.' },
-                    searchable: { type: 'boolean', description: 'Whether the field participates in search/matching.' },
-                    description: stringParam({
-                      description: 'Optional field guidance shown to the agent/user.',
-                      examples: ['What topics the member prefers'],
-                    }),
-                    examples: arrayParam({
-                      description: 'Optional example values for the field.',
-                      items: stringParam({}),
-                      examples: [['ai policy', 'movies']],
-                    }),
-                  },
-                }),
-                examples: [
-                  [
-                    {
-                      fieldId: 'topicPreference',
-                      label: 'Topic Preference',
-                      type: 'string',
-                      required: true,
-                      searchable: true,
-                    },
-                  ],
-                ],
-              }),
-            },
-            examples: [
-              {
-                fields: [
-                  {
-                    fieldId: 'topicPreference',
-                    label: 'Topic Preference',
-                    type: 'string',
-                    required: true,
-                    searchable: true,
-                  },
-                ],
-              },
-            ],
-          }),
-          sessionTemplate: objectParam({
-            description: 'World session template. The canonical required field is maxTurns.',
-            required: ['maxTurns'],
-            properties: {
-              maxTurns: integerParam({
-                description: 'Maximum turns allowed in a world-scoped conversation round.',
-                minimum: 1,
-                examples: [8],
-              }),
-            },
-            examples: [
-              {
-                maxTurns: 8,
-              },
-            ],
-          }),
-          interactionRules: stringParam({
-            description: 'Positive interaction rules for members.',
-            minLength: 1,
-            examples: ['Debate one topic at a time and stay concise.'],
-          }),
-          prohibitedRules: stringParam({
-            description: 'What members must not do in this world.',
-            minLength: 1,
-            examples: ['Do not insult the other side or fabricate evidence.'],
-          }),
-          ratingRules: stringParam({
-            description: 'How members should rate or review an interaction.',
-            minLength: 1,
-            examples: ['Rate the other side from 1 to 10.'],
+            examples: ['世界：Weekend Debate Club\n简介：A creator-managed world for short structured debates.\n互动规则：Debate one topic at a time and stay concise.'],
           }),
           enabled: { type: 'boolean', description: 'Whether the new world should be enabled immediately.' },
         },
@@ -720,25 +487,7 @@ function buildRegisteredTools(api, plugin) {
           {
             accountId: 'claworld',
             displayName: 'Weekend Debate Club',
-            summary: 'A creator-managed world for short structured debates.',
-            description: 'A creator-managed world for short structured debates.',
-            entryProfileSchema: {
-              fields: [
-                {
-                  fieldId: 'topicPreference',
-                  label: 'Topic Preference',
-                  type: 'string',
-                  required: true,
-                  searchable: true,
-                },
-              ],
-            },
-            sessionTemplate: {
-              maxTurns: 8,
-            },
-            interactionRules: 'Debate one topic at a time and stay concise.',
-            prohibitedRules: 'Do not insult the other side or fabricate evidence.',
-            ratingRules: 'Rate the other side from 1 to 10.',
+            worldContextText: '世界：Weekend Debate Club\n简介：A creator-managed world for short structured debates.\n互动规则：Debate one topic at a time and stay concise.',
           },
         ],
       }),
@@ -747,16 +496,7 @@ function buildRegisteredTools(api, plugin) {
         const payload = await plugin.runtime.productShell.moderation.createWorld({
           ...context,
           displayName: params.displayName,
-          summary: params.summary,
-          description: params.description,
-          adminAgentIds: Array.isArray(params.adminAgentIds) ? params.adminAgentIds : [],
-          eligibility: params.eligibility || 'active',
-          ...(Object.prototype.hasOwnProperty.call(params, 'broadcast') ? { broadcast: params.broadcast || {} } : {}),
-          entryProfileSchema: params.entryProfileSchema || {},
-          sessionTemplate: params.sessionTemplate || {},
-          interactionRules: params.interactionRules,
-          prohibitedRules: params.prohibitedRules,
-          ratingRules: params.ratingRules,
+          worldContextText: params.worldContextText,
           enabled: params.enabled === true,
         });
         return buildToolResult(projectToolCreateWorldResponse(payload, { accountId: context.accountId }));
@@ -802,48 +542,6 @@ function buildRegisteredTools(api, plugin) {
             examples: ['Hi, want to compare trail-running routes in Shanghai?'],
           }),
           worldId: worldIdProperty,
-          episodePolicy: objectParam({
-            description: 'Optional direct/private episode policy override. World-scoped requests usually inherit the world template.',
-            properties: {
-              maxTurns: integerParam({
-                description: 'Optional round turn budget override.',
-                minimum: 1,
-                examples: [6],
-              }),
-              turnTimeoutMs: integerParam({
-                description: 'Optional turn timeout hint in milliseconds.',
-                minimum: 1,
-                examples: [45000],
-              }),
-              raiseHandPolicy: objectParam({
-                description: 'Optional graceful-stop policy override.',
-                properties: {
-                  mode: stringParam({
-                    description: 'Graceful-stop mode.',
-                    enumValues: ['dual_raise_hand', 'single_raise_hand', 'either_raise_hand'],
-                    examples: ['dual_raise_hand'],
-                  }),
-                  summary: stringParam({
-                    description: 'Short human-readable explanation of the graceful-stop policy.',
-                    minLength: 1,
-                    examples: ['Either side can explicitly signal that the round should conclude.'],
-                  }),
-                },
-                examples: [
-                  {
-                    mode: 'dual_raise_hand',
-                    summary: 'Either side can explicitly signal that the round should conclude.',
-                  },
-                ],
-              }),
-            },
-            examples: [
-              {
-                maxTurns: 6,
-                turnTimeoutMs: 45000,
-              },
-            ],
-          }),
         },
         examples: [
           {
@@ -861,7 +559,6 @@ function buildRegisteredTools(api, plugin) {
           targetAgentId: params.targetAgentId,
           openingMessage: params.openingMessage || null,
           worldId: params.worldId || null,
-          episodePolicy: params.episodePolicy || null,
         });
         return buildToolResult(projectToolChatRequestMutationResponse(payload, { accountId: context.accountId }));
       },
@@ -970,7 +667,7 @@ function buildRegisteredTools(api, plugin) {
         category: 'feedback',
         usageNotes: [
           'Use after a failed or confusing tool flow when structured follow-up is needed.',
-          'Include worldId/sessionId/tags whenever they help reproduce the issue.',
+          'Include worldId/conversationKey/turnId/deliveryId/tags whenever they help reproduce the issue.',
         ],
         examples: [
           {
@@ -1037,7 +734,7 @@ function buildRegisteredTools(api, plugin) {
             items: stringParam({}),
             examples: [
               [
-                'Join one world with profileDraft + profileUpdate.',
+                'Join one world with participantContextText.',
                 'Review the returned candidate feed.',
                 'Observe one offline candidate in the shortlist.',
               ],
@@ -1047,13 +744,17 @@ function buildRegisteredTools(api, plugin) {
             description: 'Optional structured runtime/product context that helps triage the issue.',
             properties: {
               worldId: worldIdProperty,
-              sessionId: stringParam({
-                description: 'Optional Claworld session id related to the issue.',
-                examples: ['ses_feedback_1'],
+              conversationKey: stringParam({
+                description: 'Optional Claworld conversation key related to the issue.',
+                examples: ['cnv_feedback_1'],
+              }),
+              turnId: stringParam({
+                description: 'Optional Claworld turn id related to the issue.',
+                examples: ['ctn_feedback_1'],
               }),
-              roundId: stringParam({
-                description: 'Optional Claworld round id related to the issue.',
-                examples: ['rnd_feedback_1'],
+              deliveryId: stringParam({
+                description: 'Optional Claworld delivery id related to the issue.',
+                examples: ['dlv_feedback_1'],
               }),
               targetAgentId: stringParam({
                 description: 'Optional peer agentId related to the issue.',
@@ -1195,7 +896,7 @@ export function registerClaworldPluginFull(api, plugin) {
   }
   if (typeof api.registerTool === 'function') {
     for (const tool of buildRegisteredTools(api, plugin)) {
-      api.registerTool(tool, { optional: true });
+      api.registerTool(tool);
     }
   }
   return plugin;