@xfxstudio/claworld 2026.5.27-testing.1 → 2026.5.28-testing.2

package/src/openclaw/plugin/register.js

@@ -1,4 +1,7 @@
-import { createClaworldChannelPlugin } from './claworld-channel-plugin.js';
+import {
+  createClaworldChannelPlugin,
+  recordClaworldRuntimeAssistantOutput,
+} from './claworld-channel-plugin.js';
 import {
   projectToolChatRequestMutationResponse,
   projectToolCreateWorldResponse,
@@ -26,6 +29,7 @@ import {
   CHAT_REQUEST_APPROVAL_POLICY_MODES,
   CHAT_REQUEST_APPROVAL_POLICY_ORIGIN_TYPES,
 } from '../../product-shell/contracts/chat-request-approval-policy.js';
+import { PUBLIC_TOOL_ACTION_CATALOG } from '../../product-shell/contracts/search-item.js';
 import {
   ACCOUNT_ACTIONS,
   arrayParam,
@@ -171,49 +175,9 @@ const MANAGE_CONVERSATION_GET_STATE_TARGET_FIELDS = Object.freeze([
   'localSessionKey',
 ]);
 
-const TERMINAL_ACCOUNT_ACTIONS = Object.freeze([
-  'view_account',
-  'activate_account',
-  'update_display_name',
-  'update_human_profile',
-  'update_agent_profile',
-  'set_discoverability',
-  'set_contactability',
-  'set_chat_policy',
-  'set_proactivity',
-  'subscribe_person',
-  'unsubscribe_person',
-]);
-
-const TERMINAL_WORLD_ACTIONS = Object.freeze([
-  'list_owned_worlds',
-  'list_joined_worlds',
-  'get_world',
-  'create_world',
-  'update_world',
-  'join_world',
-  'update_world_profile',
-  'leave_world',
-  'subscribe_world',
-  'unsubscribe_world',
-  'set_world_broadcast_preference',
-  'publish_broadcast',
-  'list_world_activity',
-  'list_broadcast_history',
-  'manage_members',
-  'list_invites',
-  'invite_member',
-  'revoke_invite',
-]);
-
-const TERMINAL_CONVERSATION_ACTIONS = Object.freeze([
-  'request',
-  'accept',
-  'reject',
-  'close',
-  'get_state',
-  'list_related',
-]);
+const TERMINAL_ACCOUNT_ACTIONS = PUBLIC_TOOL_ACTION_CATALOG.claworld_manage_account;
+const TERMINAL_WORLD_ACTIONS = PUBLIC_TOOL_ACTION_CATALOG.claworld_manage_worlds;
+const TERMINAL_CONVERSATION_ACTIONS = PUBLIC_TOOL_ACTION_CATALOG.claworld_manage_conversations;
 
 const ACCOUNT_IMPLEMENTATION_ACTIONS = Object.freeze({
   view_account: 'view',
@@ -1049,13 +1013,14 @@ function createTerminalToolAdapters(api, plugin, internalTools) {
     {
       name: manageConversationsTool,
       label: 'Claworld Manage Conversations',
-      description: 'Terminal conversation lifecycle surface for starting/re-engaging chat requests and deciding pending requests. Live turns remain owned by conversation sessions.',
+      description: 'Terminal conversation lifecycle surface for starting/re-engaging direct or world-scoped chat requests, checking state, and deciding pending requests. Use this main-session surface for user requests to contact, PK, continue, or re-engage a Claworld peer. Live turns remain owned by conversation sessions.',
       metadata: buildToolMetadata({
         category: 'conversation_management',
         usageNotes: [
           'action=request starts a direct or world-scoped chat request.',
           'action=list_related/get_state, accept, reject, and close manage product-level conversation state decisions.',
           'action=close is a backend close; natural peer-facing endings still use [[request_conversation_end]] inside the Conversation Session.',
+          'Main Session peer-facing opener/reply/final content enters Claworld through action=request or a backend-managed Conversation Session, not through local session references.',
           'Do not use this tool for live conversation turns.',
         ],
       }),
@@ -1718,17 +1683,17 @@ function buildRegisteredTools(api, plugin) {
     {
       name: 'claworld_request_chat',
       label: 'Claworld Request Chat',
-      description: 'Use in the main session to create a new Claworld chat request or re-engage a selected public identity. Do not use for live conversation turns, current-session replies, or progress relay inside an already-open Claworld chat runtime.',
+      description: 'Use in the main session to create a new Claworld chat request or re-engage a selected public identity. Do not use for live conversation turns or current-session replies.',
       metadata: buildToolMetadata({
         category: 'chat_request',
         usageNotes: [
           'Primary actor/session: main session only. Use this tool when the user wants to start a new request or re-engage someone after an earlier request or chat went silent or ended.',
-          'If the user asks to contact the same person again, call this tool again to create a fresh request or re-engagement instead of using inter-session relay.',
+          'If the user asks to contact the same person again, call this tool again to create a fresh request or re-engagement.',
           'For world-scoped chat or re-engagement, use the displayName and agentCode returned by world member search.',
           'The backend resolves the target by agentCode.',
           'If the current displayName for that agentCode no longer matches, the tool can still route by the current owner and return an explicit warning with the current displayName.',
           'openingMessage is required and must contain non-blank kickoff intent; missing or blank opener text fails with opening_message_required.',
-          'Do not use this tool for replying inside an already-open Claworld chat, for runtime live turns, or for pulling progress from a local chat session.',
+          'Do not use this tool for replying inside an already-open Claworld chat or for runtime live turns.',
           'After creation, use claworld_chat_inbox to inspect pending, expired, rejected, opening, ending, active, silent, or ended status, or wait for the peer to accept.',
           'Once accepted, the runtime owns the live conversation loop.',
         ],
@@ -1757,7 +1722,7 @@ function buildRegisteredTools(api, plugin) {
         ],
       }),
       parameters: objectParam({
-        description: 'In the main session, create a new direct or world-scoped chat request, or re-engage a previously silent or ended relationship, for one target agent. Provide the target displayName, agentCode, and non-blank openingMessage. Do not use this payload for current live replies.',
+        description: 'In the main session, create a new direct or world-scoped chat request, or re-engage a previously silent or ended relationship, for one target agent. Use this for user requests to contact, PK, continue, or send peer-facing Claworld conversation content. Provide the target displayName, agentCode, and non-blank openingMessage. Do not use this payload for current live replies.',
         required: ['accountId', 'displayName', 'agentCode', 'openingMessage'],
         properties: {
           accountId: accountIdProperty,
@@ -1805,19 +1770,19 @@ function buildRegisteredTools(api, plugin) {
     {
       name: 'claworld_chat_inbox',
       label: 'Claworld Chat Inbox',
-      description: 'Use in the main session to inspect Claworld inbox state or decide one pending chat request. Default action=list is query-only and returns pending requests, recent terminal requests, plus current or recent chats with local session references for internal tracking; action=accept or action=reject is the canonical pending-request decision surface. Do not use this tool to send a live message to the peer.',
+      description: 'Use in the main session to inspect Claworld inbox state or decide one pending chat request. Default action=list is query-only and returns pending requests, recent terminal requests, plus current or recent chats with local session references for internal tracking, summaries, diagnostics, and reports; action=accept or action=reject is the canonical pending-request decision surface. Do not use this tool to send a live message to the peer.',
       metadata: buildToolMetadata({
         category: 'chat_request',
         usageNotes: [
           'Primary actor/session: main session. Default action=list is a status and query surface across inbound and outbound items.',
           'list returns actionable pending requests, recent terminal requests such as expired/rejected, and current or recent chats.',
           'action=accept and action=reject are request-decision actions for pending requests only. They do not send a freeform peer message.',
-          'Use this tool to locate the relevant Claworld chat and the localSessionKey tied to it for internal tracking, summaries, orchestration, or follow-up against the host local session tools.',
+          'Use this tool to locate the relevant Claworld chat and the localSessionKey tied to it for internal tracking, summaries, diagnostics, or reports.',
           'localSessionKey is a local runtime reference only, not a transport address for sending a user message directly to the peer.',
           'Optional filters can narrow by direction, mode, status, worldId, chatRequestId, conversationKey, localSessionKey, or counterpartyAgentId.',
-          '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.',
-          'Do not use this tool to continue an already-open live conversation turn; use the current local chat session native reply or send flow instead.',
-          'Prefer asking the local chat session for a concise update before inspecting raw local transcript details.',
+          'For user requests to contact, PK, continue, or re-engage a Claworld peer, use claworld_manage_conversations(action=request) with the intended direct or world scope.',
+          'Peer-facing opener/reply/final content is delivered by the Conversation Session and backend conversation runtime. Main Session must not use sessions_send to write peer-facing content into a local conversation session.',
+          'Prefer Claworld conversation state, reports, and concise summaries before inspecting raw local transcript details.',
           'Global counts stay visible even when filters are applied; filtered counts describe the current narrowed result set.',
           'After action=accept or action=reject, call action=list again to refresh the inbox view.',
         ],
@@ -2191,6 +2156,20 @@ export function registerClaworldPluginFull(api, plugin) {
     throw new Error('registerClaworldPluginFull requires a plugin instance');
   }
   if (typeof api.on === 'function') {
+    api.on('llm_output', async (event = {}, ctx = {}) => {
+      const assistantTexts = Array.isArray(event?.assistantTexts)
+        ? event.assistantTexts
+        : [];
+      if (assistantTexts.length === 0) return;
+      recordClaworldRuntimeAssistantOutput({
+        sessionKey: normalizeText(ctx?.sessionKey ?? event?.sessionKey, null),
+        sessionId: normalizeText(ctx?.sessionId ?? event?.sessionId, null),
+        runId: normalizeText(ctx?.runId ?? event?.runId, null),
+        assistantTexts,
+        timestamp: event?.timestamp || ctx?.timestamp || null,
+      });
+    });
+
     api.on('before_prompt_build', async (event = {}, ctx = {}) => {
       const logger = getHookLogger(api);
       const workspaceRoot = await resolveHookWorkspaceRoot(api, event, ctx);

package/src/openclaw/runtime/feedback-helper.js

@@ -1,7 +1,7 @@
 import { resolveClaworldRuntimeConfig } from '../plugin/config-schema.js';
 import { buildRuntimeAuthHeaders } from '../plugin/account-identity.js';
-import { createRuntimeBoundaryError } from '../../lib/runtime-errors.js';
 import { collectFeedbackDiagnostics } from './feedback-diagnostics.js';
+import { fetchJson, normalizeRelayHttpBaseUrl } from './http-boundary.js';
 
 function normalizeText(value, fallback = null) {
   if (value == null) return fallback;
@@ -19,46 +19,6 @@ function normalizeObject(value) {
   return value;
 }
 
-async function fetchJson(fetchImpl, url, init = {}) {
-  let response;
-  try {
-    response = await fetchImpl(url, init);
-  } catch (error) {
-    throw createRuntimeBoundaryError({
-      code: 'relay_fetch_failed',
-      category: 'transport',
-      status: 502,
-      message: `fetch failed: ${error?.message || String(error)}`,
-      publicMessage: 'relay fetch failed',
-      recoverable: true,
-      context: {
-        fetchUrl: url,
-        fetchMethod: init?.method || 'GET',
-      },
-      cause: error,
-    });
-  }
-
-  let body = null;
-  try {
-    body = await response.json();
-  } catch {
-    body = null;
-  }
-
-  return { ok: response.ok, status: response.status, body };
-}
-
-function normalizeRelayHttpBaseUrl(serverUrl) {
-  const parsed = new URL(serverUrl);
-  if (parsed.protocol === 'ws:') parsed.protocol = 'http:';
-  if (parsed.protocol === 'wss:') parsed.protocol = 'https:';
-  parsed.pathname = '';
-  parsed.search = '';
-  parsed.hash = '';
-  return parsed.toString().replace(/\/$/, '');
-}
-
 export async function submitFeedbackReport({
   cfg = {},
   accountId = null,

package/src/openclaw/runtime/http-boundary.js

@@ -0,0 +1,49 @@
+import { createRuntimeBoundaryError } from '../../lib/runtime-errors.js';
+
+export async function fetchJson(fetchImpl, url, init = {}) {
+  let response;
+  try {
+    response = await fetchImpl(url, init);
+  } catch (error) {
+    throw createRuntimeBoundaryError({
+      code: 'relay_fetch_failed',
+      category: 'transport',
+      status: 502,
+      message: `fetch failed: ${error?.message || String(error)}`,
+      publicMessage: 'relay fetch failed',
+      recoverable: true,
+      context: {
+        fetchUrl: url,
+        fetchMethod: init?.method || 'GET',
+      },
+      cause: error,
+    });
+  }
+
+  let body = null;
+  try {
+    body = await response.json();
+  } catch {
+    body = null;
+  }
+
+  return { ok: response.ok, status: response.status, body };
+}
+
+export function normalizeRelayHttpBaseUrl(serverUrl) {
+  const parsed = new URL(serverUrl);
+  if (parsed.protocol === 'ws:') parsed.protocol = 'http:';
+  if (parsed.protocol === 'wss:') parsed.protocol = 'https:';
+  parsed.pathname = '';
+  parsed.search = '';
+  parsed.hash = '';
+  return parsed.toString().replace(/\/$/, '');
+}
+
+export function inferHttpErrorCategory(status) {
+  if (status === 401) return 'auth';
+  if (status === 403) return 'policy';
+  if (status === 409) return 'conflict';
+  if (status >= 400 && status < 500) return 'input';
+  return 'runtime';
+}

package/src/openclaw/runtime/product-shell-helper.js

@@ -2,6 +2,7 @@ import { resolveClaworldRuntimeConfig } from '../plugin/config-schema.js';
 import { buildRuntimeAuthHeaders } from '../plugin/account-identity.js';
 import { createRuntimeBoundaryError } from '../../lib/runtime-errors.js';
 import { extractBackendErrorContext } from './backend-error-context.js';
+import { fetchJson, inferHttpErrorCategory, normalizeRelayHttpBaseUrl } from './http-boundary.js';
 import {
   buildWorldSelectionPrompt as buildBackendWorldSelectionPrompt,
   resolveWorldSelection as resolveBackendWorldSelection,
@@ -419,54 +420,6 @@ export function resolveWorldSelection(worldDirectory = {}, selection = null) {
   return resolveBackendWorldSelection(worldDirectory, selection);
 }
 
-async function fetchJson(fetchImpl, url, init = {}) {
-  let response;
-  try {
-    response = await fetchImpl(url, init);
-  } catch (error) {
-    throw createRuntimeBoundaryError({
-      code: 'relay_fetch_failed',
-      category: 'transport',
-      status: 502,
-      message: `fetch failed: ${error?.message || String(error)}`,
-      publicMessage: 'relay fetch failed',
-      recoverable: true,
-      context: {
-        fetchUrl: url,
-        fetchMethod: init?.method || 'GET',
-      },
-      cause: error,
-    });
-  }
-  let body = null;
-
-  try {
-    body = await response.json();
-  } catch {
-    body = null;
-  }
-
-  return { ok: response.ok, status: response.status, body };
-}
-
-function normalizeRelayHttpBaseUrl(serverUrl) {
-  const parsed = new URL(serverUrl);
-  if (parsed.protocol === 'ws:') parsed.protocol = 'http:';
-  if (parsed.protocol === 'wss:') parsed.protocol = 'https:';
-  parsed.pathname = '';
-  parsed.search = '';
-  parsed.hash = '';
-  return parsed.toString().replace(/\/$/, '');
-}
-
-function inferHttpErrorCategory(status) {
-  if (status === 401) return 'auth';
-  if (status === 403) return 'policy';
-  if (status === 409) return 'conflict';
-  if (status >= 400 && status < 500) return 'input';
-  return 'runtime';
-}
-
 function createProductShellHttpError(action, response, { accountId = null, worldId = null } = {}) {
   const backendCode = normalizeText(response?.body?.error, null);
   const backendMessage = normalizeText(response?.body?.message, `claworld product-shell ${action} failed`);

package/src/openclaw/runtime/working-memory.js

@@ -145,6 +145,12 @@ export function buildClaworldContextPointer(options = {}) {
     'Do not load raw Claworld transcripts by default.',
     'Use the session directory before searching raw local session files.',
     'Do not treat open Claworld loops as ordinary main-session todos before checking these files.',
+    '',
+    '## Main Session Claworld Conversation Boundary',
+    '- For user requests to contact a Claworld person/member, find someone to chat with, start a PK, continue a peer conversation, or send a peer-facing message, use Claworld tools such as `claworld_search`, `claworld_get_public_profile`, and `claworld_manage_conversations`.',
+    '- Use `claworld_manage_conversations(action=request)` to create or re-engage a direct or world-scoped chat request; use `get_state` or `list_related` to inspect conversation state.',
+    '- `localSessionKey` is an internal runtime reference for state lookup, summaries, diagnostics, and reports. Peer-facing opener/reply/final text is delivered by the Conversation Session and backend conversation runtime.',
+    '- Main Session must not use `sessions_send` to place peer-facing opener/reply/final text into an `agent:...:conversation:...` session.',
   ].join('\n');
 }
 
@@ -213,6 +219,7 @@ function buildClaworldManagementStartupPrompt(options = {}) {
     '## Reporting Route',
     '- Reports and approval requests follow the Reporting Rules in the `claworld-management-session` skill.',
     buildClaworldManagementReportingInstruction(mainSessionKey),
+    '- Use the reporting route for Main Session context and owner-report continuity. Peer-facing opener/reply/final content for Claworld conversations goes through `claworld_manage_conversations` and the backend Conversation Session runtime.',
     '- If no safe Main route exists or session send fails, write a report artifact, journal the failure, and retry or surface it on the next Main route.',
   ].join('\n');
 }

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

@@ -2,6 +2,7 @@ import { resolveClaworldRuntimeConfig } from '../plugin/config-schema.js';
 import { buildRuntimeAuthHeaders } from '../plugin/account-identity.js';
 import { createRuntimeBoundaryError } from '../../lib/runtime-errors.js';
 import { extractBackendErrorContext } from './backend-error-context.js';
+import { fetchJson, inferHttpErrorCategory, normalizeRelayHttpBaseUrl } from './http-boundary.js';
 
 function normalizeText(value, fallback = null) {
   if (value == null) return fallback;
@@ -46,53 +47,6 @@ function normalizeMembershipList(payload = {}) {
   };
 }
 
-async function fetchJson(fetchImpl, url, init = {}) {
-  let response;
-  try {
-    response = await fetchImpl(url, init);
-  } catch (error) {
-    throw createRuntimeBoundaryError({
-      code: 'relay_fetch_failed',
-      category: 'transport',
-      status: 502,
-      message: `fetch failed: ${error?.message || String(error)}`,
-      publicMessage: 'relay fetch failed',
-      recoverable: true,
-      context: {
-        fetchUrl: url,
-        fetchMethod: init?.method || 'GET',
-      },
-      cause: error,
-    });
-  }
-  let body = null;
-  try {
-    body = await response.json();
-  } catch {
-    body = null;
-  }
-  return { ok: response.ok, status: response.status, body };
-}
-
-function normalizeRelayHttpBaseUrl(serverUrl) {
-  const parsed = new URL(serverUrl);
-  if (parsed.protocol === 'ws:') parsed.protocol = 'http:';
-  if (parsed.protocol === 'wss:') parsed.protocol = 'https:';
-  parsed.pathname = '';
-  parsed.search = '';
-  parsed.hash = '';
-  return parsed.toString().replace(/\/$/, '');
-}
-
-function inferHttpErrorCategory(status) {
-  if (status === 401) return 'auth';
-  if (status === 403) return 'policy';
-  if (status === 404) return 'input';
-  if (status === 409) return 'conflict';
-  if (status >= 400 && status < 500) return 'input';
-  return 'runtime';
-}
-
 function createWorldMembershipHttpError(action, response, { accountId = null, worldId = null } = {}) {
   const backendCode = normalizeText(response?.body?.error, null);
   const backendMessage = normalizeText(response?.body?.message, `claworld world membership ${action} failed`);

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

@@ -2,6 +2,7 @@ import { resolveClaworldRuntimeConfig } from '../plugin/config-schema.js';
 import { buildRuntimeAuthHeaders } from '../plugin/account-identity.js';
 import { createRuntimeBoundaryError } from '../../lib/runtime-errors.js';
 import { extractBackendErrorContext } from './backend-error-context.js';
+import { fetchJson, inferHttpErrorCategory, normalizeRelayHttpBaseUrl } from './http-boundary.js';
 import { normalizeWorldJoinResponse } from './product-shell-helper.js';
 
 function normalizeText(value, fallback = null) {
@@ -233,52 +234,6 @@ function normalizeWorldBroadcastResponse(payload = {}) {
   };
 }
 
-async function fetchJson(fetchImpl, url, init = {}) {
-  let response;
-  try {
-    response = await fetchImpl(url, init);
-  } catch (error) {
-    throw createRuntimeBoundaryError({
-      code: 'relay_fetch_failed',
-      category: 'transport',
-      status: 502,
-      message: `fetch failed: ${error?.message || String(error)}`,
-      publicMessage: 'relay fetch failed',
-      recoverable: true,
-      context: {
-        fetchUrl: url,
-        fetchMethod: init?.method || 'GET',
-      },
-      cause: error,
-    });
-  }
-  let body = null;
-  try {
-    body = await response.json();
-  } catch {
-    body = null;
-  }
-  return { ok: response.ok, status: response.status, body };
-}
-
-function normalizeRelayHttpBaseUrl(serverUrl) {
-  const parsed = new URL(serverUrl);
-  if (parsed.protocol === 'ws:') parsed.protocol = 'http:';
-  if (parsed.protocol === 'wss:') parsed.protocol = 'https:';
-  parsed.pathname = '';
-  parsed.search = '';
-  parsed.hash = '';
-  return parsed.toString().replace(/\/$/, '');
-}
-
-function inferHttpErrorCategory(status) {
-  if (status === 401) return 'auth';
-  if (status === 403) return 'policy';
-  if (status === 409) return 'conflict';
-  if (status >= 400 && status < 500) return 'input';
-  return 'runtime';
-}
-
 function createModerationHttpError(action, response, { accountId = null, worldId = null } = {}) {
   const backendCode = normalizeText(response?.body?.error, null);
   const backendMessage = normalizeText(response?.body?.message, `claworld world ${action} failed`);