@xfxstudio/claworld 0.2.7 → 0.2.8

package/src/openclaw/plugin/register.js

@@ -1,6 +1,6 @@
 import { createClaworldChannelPlugin } from './claworld-channel-plugin.js';
 import {
-  projectToolChatInboxResponse,
+  projectToolChatRequestListResponse,
   projectToolChatRequestMutationResponse,
   projectToolCreateWorldResponse,
   projectToolManagedWorldResponse,
@@ -19,8 +19,6 @@ import {
   normalizeRuntimeBoundaryError,
 } from '../../lib/runtime-errors.js';
 
-const INTERNAL_REQUESTER_SESSION_KEY_PARAM = '__claworldRequesterSessionKey';
-
 function normalizeText(value, fallback = null) {
   if (value == null) return fallback;
   const normalized = String(value).trim();
@@ -168,7 +166,6 @@ async function resolveToolContext(api, plugin, params = {}) {
       accountId,
       runtimeConfig,
       agentId: normalizeText(params.agentId, runtimeConfig.relay?.agentId || null),
-      requesterSessionKey: normalizeText(params[INTERNAL_REQUESTER_SESSION_KEY_PARAM], null),
     });
   }
 
@@ -178,7 +175,6 @@ async function resolveToolContext(api, plugin, params = {}) {
     accountId,
     runtimeConfig,
     agentId,
-    requesterSessionKey: normalizeText(params[INTERNAL_REQUESTER_SESSION_KEY_PARAM], null),
   };
 }
 
@@ -266,6 +262,56 @@ function buildToolMetadata({
   };
 }
 
+const MANAGE_WORLD_ACTIONS = Object.freeze([
+  'list',
+  'get',
+  'update_context',
+  'pause',
+  'close',
+  'resume',
+]);
+
+function normalizeManageWorldAction(value, fallback = null) {
+  const normalized = normalizeText(value, fallback);
+  return MANAGE_WORLD_ACTIONS.includes(normalized) ? normalized : fallback;
+}
+
+function inferManageWorldAction(params = {}) {
+  const explicitAction = normalizeManageWorldAction(params.action, null);
+  if (explicitAction) return explicitAction;
+  if (!normalizeText(params.worldId, null)) return 'list';
+  if (normalizeText(params.worldContextText, null) || normalizeText(params.displayName, null)) {
+    return 'update_context';
+  }
+  return 'get';
+}
+
+function requireManageWorldField(fieldId, message = `${fieldId} is required`) {
+  throw createRuntimeBoundaryError({
+    code: 'tool_input_invalid',
+    category: 'input',
+    status: 400,
+    message,
+    publicMessage: message,
+    recoverable: true,
+    context: { field: fieldId },
+  });
+}
+
+function projectToolManageWorldActionResponse(payload = {}, { accountId = null, action = null } = {}) {
+  const resolvedAction = normalizeManageWorldAction(action, null) || 'get';
+  if (resolvedAction === 'list') {
+    return {
+      action: resolvedAction,
+      ...projectToolOwnedWorldsResponse(payload, { accountId }),
+    };
+  }
+  return {
+    action: resolvedAction,
+    ...projectToolManagedWorldResponse(payload, { accountId }),
+  };
+}
+
 function buildRegisteredTools(api, plugin) {
   const accountIdProperty = stringParam({
     description: 'Claworld account id to execute the tool against. In managed installs this is usually the dedicated claworld account.',
@@ -509,67 +555,31 @@ function buildRegisteredTools(api, plugin) {
       },
     },
     {
-      name: 'claworld_list_owned_worlds',
-      label: 'Claworld List Owned Worlds',
-      description: 'Owner-focused governance tool. List the worlds owned by the current account before choosing one to manage.',
+      name: 'claworld_manage_world',
+      label: 'Claworld Manage World',
+      description: 'Unified owner-only world governance tool. List owned worlds, inspect one world, update worldContextText, or change world lifecycle to paused/closed/enabled.',
       metadata: buildToolMetadata({
         category: 'world_management',
         usageNotes: [
-          'Use when the user wants to inspect or pick from worlds they own.',
-          'This tool only returns owned worlds, not general directory worlds.',
-          'Pair this with claworld_manage_world for owner-only worldContext updates.',
+          'Use action=list to inspect the worlds owned by the current account.',
+          'Use action=get to inspect one owned world before changing it.',
+          'Use action=update_context to change worldContextText and optional displayName.',
+          'Use action=pause, action=close, or action=resume for owner-only lifecycle changes.',
         ],
         examples: [
           {
             title: 'List owned worlds',
             input: {
               accountId: 'claworld',
+              action: 'list',
             },
             outcome: 'Returns owner-managed worlds for the current account.',
           },
-        ],
-      }),
-      parameters: objectParam({
-        description: 'Minimal payload for listing worlds owned by the current account.',
-        required: ['accountId'],
-        properties: {
-          accountId: accountIdProperty,
-          includeDisabled: {
-            type: 'boolean',
-            description: 'Whether to include disabled or draft owned worlds.',
-          },
-        },
-        examples: [
-          {
-            accountId: 'claworld',
-          },
-        ],
-      }),
-      async execute(_toolCallId, params = {}) {
-        const context = await resolveToolContext(api, plugin, params);
-        const payload = await plugin.runtime.productShell.moderation.listOwnedWorlds({
-          ...context,
-          includeDisabled: params.includeDisabled !== false,
-        });
-        return buildToolResult(projectToolOwnedWorldsResponse(payload, { accountId: context.accountId }));
-      },
-    },
-    {
-      name: 'claworld_manage_world',
-      label: 'Claworld Manage World',
-      description: 'Owner-only world management tool. Update the canonical worldContextText for one owner-managed world, with optional displayName/enabled changes.',
-      metadata: buildToolMetadata({
-        category: 'world_management',
-        usageNotes: [
-          'Use only when the current agent owns the target world.',
-          'This is the minimal management tool on the current public surface.',
-          'Prefer updating worldContextText directly instead of editing legacy world schema fields.',
-        ],
-        examples: [
           {
             title: 'Update one owned world context',
             input: {
               accountId: 'claworld',
+              action: 'update_context',
               worldId: 'ugc-weekend-debate-club',
               worldContextText: '世界：Weekend Debate Club [ugc-weekend-debate-club]\n简介：A creator-managed world for short structured debates.\n互动规则：Debate one topic at a time and stay concise.',
             },
@@ -578,29 +588,39 @@ function buildRegisteredTools(api, plugin) {
         ],
       }),
       parameters: objectParam({
-        description: 'Minimal owner-only world management payload.',
-        required: ['accountId', 'worldId', 'worldContextText'],
+        description: 'Owner-only world governance payload. action=list replaces the old list_owned_worlds tool.',
+        required: ['accountId'],
         properties: {
           accountId: accountIdProperty,
+          action: stringParam({
+            description: 'Owner-only governance action. If omitted, the tool infers list/get/update_context from the provided fields.',
+            enumValues: MANAGE_WORLD_ACTIONS,
+            examples: ['list'],
+          }),
           worldId: worldIdProperty,
           worldContextText: stringParam({
-            description: 'Replacement canonical world context text for the owned world.',
+            description: 'Replacement canonical world context text for update_context.',
             minLength: 1,
             examples: ['世界：Weekend Debate Club [ugc-weekend-debate-club]\n简介：A creator-managed world for short structured debates.\n互动规则：Debate one topic at a time and stay concise.'],
           }),
           displayName: stringParam({
-            description: 'Optional new display name for the owned world.',
+            description: 'Optional new display name when action=update_context.',
             minLength: 1,
             examples: ['Weekend Debate Club'],
           }),
-          enabled: {
+          includeDisabled: {
             type: 'boolean',
-            description: 'Optional enabled flag for the owned world.',
+            description: 'Whether action=list should include paused, closed, or draft owned worlds.',
           },
         },
         examples: [
           {
             accountId: 'claworld',
+            action: 'list',
+          },
+          {
+            accountId: 'claworld',
+            action: 'update_context',
             worldId: 'ugc-weekend-debate-club',
             worldContextText: '世界：Weekend Debate Club [ugc-weekend-debate-club]\n简介：A creator-managed world for short structured debates.\n互动规则：Debate one topic at a time and stay concise.',
           },
@@ -608,18 +628,72 @@ function buildRegisteredTools(api, plugin) {
       }),
       async execute(_toolCallId, params = {}) {
         const context = await resolveToolContext(api, plugin, params);
-        const changes = {
-          worldContextText: params.worldContextText,
-          ...(params.displayName ? { displayName: params.displayName } : {}),
+        if (Object.prototype.hasOwnProperty.call(params, 'action')
+          && !normalizeManageWorldAction(params.action, null)) {
+          requireManageWorldField('action', 'action must be one of list, get, update_context, pause, close, or resume');
+        }
+        const action = inferManageWorldAction(params);
+        if (action === 'list') {
+          const payload = await plugin.runtime.productShell.moderation.listOwnedWorlds({
+            ...context,
+            includeDisabled: params.includeDisabled !== false,
+          });
+          return buildToolResult(projectToolManageWorldActionResponse(payload, {
+            accountId: context.accountId,
+            action,
+          }));
+        }
+
+        const worldId = normalizeText(params.worldId, null);
+        if (!worldId) requireManageWorldField('worldId');
+
+        if (action === 'get') {
+          const payload = await plugin.runtime.productShell.moderation.manageWorld({
+            ...context,
+            worldId,
+            mode: 'get',
+          });
+          return buildToolResult(projectToolManageWorldActionResponse(payload, {
+            accountId: context.accountId,
+            action,
+          }));
+        }
+
+        if (action === 'update_context') {
+          const worldContextText = normalizeText(params.worldContextText, null);
+          if (!worldContextText) requireManageWorldField('worldContextText');
+          const payload = await plugin.runtime.productShell.moderation.manageWorld({
+            ...context,
+            worldId,
+            mode: 'patch',
+            changes: {
+              worldContextText,
+              ...(normalizeText(params.displayName, null) ? { displayName: normalizeText(params.displayName, null) } : {}),
+            },
+          });
+          return buildToolResult(projectToolManageWorldActionResponse(payload, {
+            accountId: context.accountId,
+            action,
+          }));
+        }
+
+        const statusByAction = {
+          pause: 'paused',
+          close: 'closed',
+          resume: 'enabled',
         };
+        const status = statusByAction[action] || null;
         const payload = await plugin.runtime.productShell.moderation.manageWorld({
           ...context,
-          worldId: params.worldId,
+          worldId,
           mode: 'patch',
-          changes,
-          ...(Object.prototype.hasOwnProperty.call(params, 'enabled') ? { enabled: params.enabled === true } : {}),
+          status,
+          enabled: action === 'resume',
         });
-        return buildToolResult(projectToolManagedWorldResponse(payload, { accountId: context.accountId }));
+        return buildToolResult(projectToolManageWorldActionResponse(payload, {
+          accountId: context.accountId,
+          action,
+        }));
       },
     },
     {
@@ -630,7 +704,7 @@ function buildRegisteredTools(api, plugin) {
         category: 'chat_request',
         usageNotes: [
           'For world-scoped chat, use the targetAgentId returned by claworld_join_world.',
-          'After creation, use claworld_chat_inbox or wait for the peer to accept.',
+          'After creation, use claworld_list_chat_requests or wait for the peer to accept.',
           'Once accepted, the runtime owns the live conversation loop.',
         ],
         examples: [
@@ -684,36 +758,33 @@ function buildRegisteredTools(api, plugin) {
       },
     },
     {
-      name: 'claworld_chat_inbox',
-      label: 'Claworld Chat Inbox',
-      description: 'Canonical chat inbox tool. Review pending requests plus current or recent Claworld chats and the local session references you can use to check progress.',
+      name: 'claworld_list_chat_requests',
+      label: 'Claworld List Chat Requests',
+      description: 'Canonical review tool for pending chat requests after request_chat or before accept_chat_request.',
       metadata: buildToolMetadata({
         category: 'chat_request',
         usageNotes: [
-          'Use to review pending inbound requests waiting for acceptance.',
-          'Use to locate the relevant Claworld chat and the local sessionKey tied to it.',
-          'If the user asks about one chat, first locate it here, then use your local session-send tool to ask that local session for a progress update or short summary.',
-          'Prefer asking the local chat session for a concise update before inspecting raw local transcript details.',
-          'Use direction=outbound when focusing on chats you initiated.',
+          'Use to review inbound requests waiting for acceptance.',
+          'Use direction=outbound when checking whether a previously-created request is still pending.',
         ],
         examples: [
           {
-            title: 'Review inbound chat state',
+            title: 'Review inbound requests',
             input: {
               accountId: 'claworld',
               direction: 'inbound',
             },
-            outcome: 'Returns pending requests plus related chats for the current account.',
+            outcome: 'Returns the current pending or accepted chat requests for the current account.',
           },
         ],
       }),
       parameters: objectParam({
-        description: 'Review overall Claworld chat state for the current account before deciding whether to accept a request or query one local chat session for progress.',
+        description: 'List direct or world-scoped chat requests for the current account.',
         required: ['accountId'],
         properties: {
           accountId: accountIdProperty,
           direction: stringParam({
-            description: 'Filter to inbound or outbound chat state from the current account perspective.',
+            description: 'Filter to inbound requests you can review or outbound requests you previously created.',
             enumValues: ['inbound', 'outbound'],
             examples: ['inbound'],
           }),
@@ -727,11 +798,11 @@ function buildRegisteredTools(api, plugin) {
       }),
       async execute(_toolCallId, params = {}) {
         const context = await resolveToolContext(api, plugin, params);
-        const payload = await plugin.helpers.social.listChatInbox({
+        const payload = await plugin.helpers.social.listChatRequests({
           ...context,
           direction: params.direction || null,
         });
-        return buildToolResult(projectToolChatInboxResponse(payload, { accountId: context.accountId }));
+        return buildToolResult(projectToolChatRequestListResponse(payload, { accountId: context.accountId }));
       },
     },
     {
@@ -741,7 +812,7 @@ function buildRegisteredTools(api, plugin) {
       metadata: buildToolMetadata({
         category: 'chat_request',
         usageNotes: [
-          'Use the chatRequestId returned by claworld_chat_inbox pendingRequests.',
+          'Use the chatRequestId returned by claworld_list_chat_requests.',
           'After acceptance, do not try to send a separate raw message tool call; wait for runtime-owned live conversation.',
         ],
         examples: [
@@ -761,7 +832,7 @@ function buildRegisteredTools(api, plugin) {
         properties: {
           accountId: accountIdProperty,
           chatRequestId: stringParam({
-            description: 'Canonical chat request id returned by claworld_chat_inbox pendingRequests.',
+            description: 'Canonical chat request id returned by claworld_list_chat_requests.',
             minLength: 1,
             examples: ['req_demo_1'],
           }),
@@ -782,6 +853,54 @@ function buildRegisteredTools(api, plugin) {
         return buildToolResult(projectToolChatRequestMutationResponse(payload, { accountId: context.accountId }));
       },
     },
+    {
+      name: 'claworld_reject_chat_request',
+      label: 'Claworld Reject Chat Request',
+      description: 'Canonical rejection tool for one inbound chat request. Use this when the current account explicitly declines the request instead of accepting it.',
+      metadata: buildToolMetadata({
+        category: 'chat_request',
+        usageNotes: [
+          'Use the chatRequestId returned by claworld_list_chat_requests.',
+          'Use only for inbound requests that the current account wants to reject.',
+        ],
+        examples: [
+          {
+            title: 'Reject one inbound request',
+            input: {
+              accountId: 'claworld',
+              chatRequestId: 'req_demo_1',
+            },
+            outcome: 'Marks the request rejected and returns the closed request projection.',
+          },
+        ],
+      }),
+      parameters: objectParam({
+        description: 'Reject one inbound chat request for the current account.',
+        required: ['accountId', 'chatRequestId'],
+        properties: {
+          accountId: accountIdProperty,
+          chatRequestId: stringParam({
+            description: 'Canonical chat request id returned by claworld_list_chat_requests.',
+            minLength: 1,
+            examples: ['req_demo_1'],
+          }),
+        },
+        examples: [
+          {
+            accountId: 'claworld',
+            chatRequestId: 'req_demo_1',
+          },
+        ],
+      }),
+      async execute(_toolCallId, params = {}) {
+        const context = await resolveToolContext(api, plugin, params);
+        const payload = await plugin.helpers.social.rejectChatRequest({
+          ...context,
+          chatRequestId: params.chatRequestId,
+        });
+        return buildToolResult(projectToolChatRequestMutationResponse(payload, { accountId: context.accountId }));
+      },
+    },
     {
       name: 'claworld_submit_feedback',
       label: 'Claworld Submit Feedback',
@@ -1014,19 +1133,6 @@ export function registerClaworldPluginFull(api, plugin) {
   if (!plugin) {
     throw new Error('registerClaworldPluginFull requires a plugin instance');
   }
-  if (typeof api.on === 'function') {
-    api.on('before_tool_call', async (event, ctx) => {
-      if (event?.toolName !== 'claworld_request_chat') return;
-      const requesterSessionKey = normalizeText(ctx?.sessionKey, null);
-      if (!requesterSessionKey) return;
-      return {
-        params: {
-          ...(event?.params && typeof event.params === 'object' && !Array.isArray(event.params) ? event.params : {}),
-          [INTERNAL_REQUESTER_SESSION_KEY_PARAM]: requesterSessionKey,
-        },
-      };
-    });
-  }
   if (typeof api.registerHttpRoute === 'function') {
     api.registerHttpRoute(buildClaworldStatusRoute(plugin));
   }

package/src/openclaw/plugin/relay-client.js

@@ -564,7 +564,7 @@ export class ClaworldRelayClient extends EventEmitter {
     config,
     agentId,
     credential = null,
-    clientVersion = 'claworld-plugin/0.2.7',
+    clientVersion = 'claworld-plugin/0.1.5',
     sessionTarget,
     fallbackTarget,
   } = {}) {
@@ -978,6 +978,7 @@ export class ClaworldRelayClient extends EventEmitter {
           stage: 'reply_fallback',
           deliveryId: envelope.deliveryId,
           sessionKey: envelope.sessionKey,
+          fallbackFrom: error?.code || error?.message || null,
         }),
       });
     }
@@ -1116,9 +1117,6 @@ export class ClaworldRelayClient extends EventEmitter {
         kickoffBrief: normalized.kickoffBrief || null,
         openingMessage: normalized.openingMessage || null,
         worldId: normalized.conversation?.worldId || null,
-        requestContext: requestContext && typeof requestContext === 'object' && !Array.isArray(requestContext)
-          ? requestContext
-          : undefined,
       }),
     }, {
       code: 'relay_request_create_failed',
@@ -1151,6 +1149,18 @@ export class ClaworldRelayClient extends EventEmitter {
     return result;
   }
 
+  async rejectChatRequest(requestId, { actorAgentId, ...options } = {}) {
+    return await this.requestJson(`/v1/chat-requests/${requestId}/reject`, {
+      method: 'POST',
+      headers: buildRuntimeAuthHeaders(this.runtimeConfig, { 'content-type': 'application/json' }),
+      body: JSON.stringify({ actorAgentId, ...options }),
+    }, {
+      code: 'relay_request_reject_failed',
+      message: 'failed to reject relay chat request',
+      publicMessage: 'failed to reject relay chat request',
+    });
+  }
+
   async deliverMessage({ fromAgentId, toAddress, payload = {}, conversation = {} } = {}) {
     return await this.requestJson('/v1/messages', {
       method: 'POST',

package/src/openclaw/runtime/tool-contracts.js

@@ -391,7 +391,7 @@ export function projectToolOwnedWorldsResponse(payload = {}, { accountId = null
     ? payload.items.map((world) => ({
       worldId: world.worldId,
       displayName: world.displayName,
-      summary: world.summary,
+      worldContextText: normalizeText(world.worldContextText, null),
       enabled: normalizeOptionalBoolean(world.enabled, null),
       status: normalizeText(world.status, null),
       worldRole: projectWorldRole(world.worldRole, null),
@@ -622,22 +622,6 @@ function projectChatRequestItem(request = {}) {
   };
 }
 
-function projectChatInboxChatItem(chat = {}) {
-  if (!chat || typeof chat !== 'object' || Array.isArray(chat)) return null;
-  return {
-    chatRequestId: normalizeText(chat.chatRequestId, null),
-    status: normalizeText(chat.status, null),
-    direction: normalizeText(chat.direction, null),
-    createdAt: normalizeText(chat.createdAt, null),
-    updatedAt: normalizeText(chat.updatedAt, null),
-    lastTurnAt: normalizeText(chat.lastTurnAt, null),
-    conversationKey: normalizeText(chat.conversationKey, null),
-    localSessionKey: normalizeText(chat.localSessionKey, normalizeText(chat.sessionKey, null)),
-    counterparty: projectToolAgentSummary(chat.counterparty),
-    conversation: normalizeConversationScopeDetails(chat.conversation),
-  };
-}
-
 export function projectToolFriendRequestMutationResponse(result = {}, { accountId = null } = {}) {
   return {
     status: result.alreadyFriends === true
@@ -706,26 +690,3 @@ export function projectToolChatRequestListResponse(result = {}, { accountId = nu
     items,
   };
 }
-
-export function projectToolChatInboxResponse(result = {}, { accountId = null } = {}) {
-  const pendingRequests = Array.isArray(result.pendingRequests)
-    ? result.pendingRequests.map((request) => projectChatRequestItem(request)).filter(Boolean)
-    : [];
-  const chats = Array.isArray(result.chats)
-    ? result.chats.map((chat) => projectChatInboxChatItem(chat)).filter(Boolean)
-    : [];
-  return {
-    accountId: normalizeText(accountId, null),
-    counts: result.counts && typeof result.counts === 'object' && !Array.isArray(result.counts)
-      ? {
-          pendingRequestCount: normalizeInteger(result.counts.pendingRequestCount, pendingRequests.length),
-          chatCount: normalizeInteger(result.counts.chatCount, chats.length),
-        }
-      : {
-          pendingRequestCount: pendingRequests.length,
-          chatCount: chats.length,
-        },
-    pendingRequests,
-    chats,
-  };
-}

package/src/openclaw/runtime/tool-inventory.js

@@ -2,8 +2,9 @@ export const CLAWORLD_TOOL_CONTRACT_VERSION = 'v1';
 
 export const CLAWORLD_CHAT_REQUEST_TOOL_NAMES = Object.freeze([
   'claworld_request_chat',
-  'claworld_chat_inbox',
+  'claworld_list_chat_requests',
   'claworld_accept_chat_request',
+  'claworld_reject_chat_request',
 ]);
 
 export const CLAWORLD_BOOTSTRAP_TOOL_NAMES = Object.freeze([
@@ -22,11 +23,11 @@ export const CLAWORLD_WORLD_TOOL_NAMES = Object.freeze([
 
 export const CLAWORLD_WORLD_ADMIN_PUBLIC_TOOL_NAMES = Object.freeze([
   'claworld_create_world',
-  'claworld_list_owned_worlds',
   'claworld_manage_world',
 ]);
 
 export const CLAWORLD_COMPATIBILITY_TOOL_NAMES = Object.freeze([
+  'claworld_list_owned_worlds',
   'claworld_prepare_world_join',
   'claworld_search_world',
 ]);

package/src/openclaw/runtime/world-moderation-helper.js

@@ -287,6 +287,7 @@ export async function manageModeratedWorld({
   mode = 'get',
   changes = null,
   enabled = null,
+  status = null,
   fetchImpl,
   logger = console,
 } = {}) {
@@ -340,6 +341,7 @@ export async function manageModeratedWorld({
       agentId: resolvedAgentId,
       ...(changes && typeof changes === 'object' ? { changes } : {}),
       ...(enabled == null ? {} : { enabled }),
+      ...(normalizeText(status, null) ? { status: normalizeText(status, null) } : {}),
     }),
   });
 

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

@@ -56,10 +56,7 @@ export function registerChatRequestRoutes(app, { chatRequestService, store }) {
         targetAgentId: req.body?.targetAgentId,
         kickoffBrief: req.body?.kickoffBrief,
         openingMessage: req.body?.openingMessage,
-        openingPayload: req.body?.openingPayload,
         worldId: req.body?.worldId,
-        requestContext: req.body?.requestContext,
-        source: req.body?.source,
       });
       res.status(201).json(result);
     } catch (error) {
@@ -78,7 +75,7 @@ export function registerChatRequestRoutes(app, { chatRequestService, store }) {
     if (!authAgent.agentId) return sendMissingAgentIdentity(res);
 
     try {
-      const result = chatRequestService.listChatInbox({
+      const result = chatRequestService.listChatRequests({
         agentId: authAgent.agentId,
         direction: req.query.direction,
       });