@xfxstudio/claworld 0.1.4 → 0.2.0

package/src/product-shell/orchestration/world-conversation-text.js

@@ -0,0 +1,231 @@
+const DEFAULT_TEMPLATE_REFS = {
+  opening: 'world.conversation.opening',
+  convergence: 'world.conversation.convergence',
+  stateChanged: 'world.conversation.state_changed',
+};
+
+function normalizeText(value, fallback = null) {
+  if (value == null) return fallback;
+  const normalized = String(value).trim();
+  return normalized || fallback;
+}
+
+function normalizeInteger(value, fallback = null) {
+  const normalized = Number(value);
+  if (!Number.isFinite(normalized)) return fallback;
+  return Math.trunc(normalized);
+}
+
+function normalizePositiveInteger(value, fallback = null) {
+  const normalized = normalizeInteger(value, fallback);
+  if (normalized == null || normalized <= 0) return fallback;
+  return normalized;
+}
+
+function normalizeTurnRule(rule = {}, index = 0) {
+  return {
+    id: rule.id || `turn_rule_${index + 1}`,
+    trigger: rule.trigger || 'turn_threshold',
+    atTurn: Number.isFinite(Number(rule.atTurn)) ? Math.max(0, Number(rule.atTurn)) : null,
+    visibility: rule.visibility || 'both',
+    role: rule.role || 'system',
+    templateRef: rule.templateRef || `world.turn.rule.${index + 1}`,
+    text: rule.text || null,
+    once: rule.once !== false,
+  };
+}
+
+function buildMessage({
+  conversationId = null,
+  trigger,
+  role = 'system',
+  visibility = 'both',
+  templateRef = null,
+  text = null,
+  metadata = {},
+}) {
+  return {
+    conversationId: normalizeText(conversationId, null),
+    trigger,
+    role,
+    visibility,
+    templateRef,
+    text,
+    metadata,
+  };
+}
+
+function formatConversationOverview(detail = {}) {
+  const conversationOverview = detail.conversationOverview && typeof detail.conversationOverview === 'object'
+    ? detail.conversationOverview
+    : {};
+  const mode = normalizeText(detail.conversationMode || conversationOverview.mode, null);
+  const parts = [];
+
+  if (mode) parts.push(`${mode} mode`);
+
+  return parts.length > 0 ? parts.join(', ') : null;
+}
+
+export function buildWorldConversationContextEvent(detail = {}) {
+  const worldId = normalizeText(detail.worldId || detail.world?.worldId, null);
+  if (!worldId) return null;
+  const worldContextText = normalizeText(
+    detail.world?.worldContextText,
+    normalizeText(detail.worldContextText, null),
+  );
+  if (worldContextText) return worldContextText;
+
+  const displayName = normalizeText(detail.displayName || detail.world?.displayName || detail.worldDisplayName, worldId);
+  const summary = normalizeText(detail.summary || detail.world?.summary, null);
+  const sessionSummary = formatConversationOverview(detail);
+  const conversationOverview = detail.conversationOverview && typeof detail.conversationOverview === 'object'
+    ? detail.conversationOverview
+    : {};
+  const openingText = normalizeText(conversationOverview.openingText, null);
+  const convergenceText = normalizeText(conversationOverview.convergence?.text, null);
+  const interactionRules = normalizeText(detail.interactionRules, null);
+  const prohibitedRules = normalizeText(detail.prohibitedRules, null);
+  const ratingRules = normalizeText(detail.ratingRules, null);
+
+  const lines = [
+    'Internal Claworld world context for this conversation.',
+    'Do not acknowledge, paraphrase, or announce this setup to the peer unless it is directly relevant to their message.',
+    `World: ${displayName} [${worldId}]`,
+    summary ? `Summary: ${summary}` : null,
+    sessionSummary ? `Conversation overview: ${sessionSummary}` : null,
+    'Interruption handling: prefer reconnect/resume. Temporary silence or reconnect churn is not the normal way to close a round.',
+    openingText ? `Opening focus: ${openingText}` : null,
+    interactionRules ? `Interaction rules: ${interactionRules}` : null,
+    prohibitedRules ? `Prohibited rules: ${prohibitedRules}` : null,
+    ratingRules ? `Rating rules: ${ratingRules}` : null,
+    convergenceText ? `Convergence rule: ${convergenceText}` : null,
+    'Apply these world rules symmetrically when responding in this conversation.',
+  ].filter(Boolean);
+
+  return lines.join('\n');
+}
+
+export function createSystemMessageOrchestrator({ templateRefs = DEFAULT_TEMPLATE_REFS } = {}) {
+  return {
+    supportedTriggers: ['conversation_started', 'turn_threshold', 'convergence', 'state_changed'],
+    describeRuleShape() {
+      return {
+        opening_system_message: 'optional text/template ref',
+        turn_message_rules: [
+          {
+            id: 'turn_nudge_2',
+            trigger: 'turn_threshold',
+            atTurn: 2,
+            visibility: 'both',
+            role: 'system',
+            templateRef: 'world.turn.nudge',
+            once: true,
+          },
+        ],
+        convergence_message: {
+          whenRemainingTurnsLTE: 1,
+          templateRef: templateRefs.convergence,
+        },
+        state_change_messages: {
+          active_to_review: templateRefs.stateChanged,
+        },
+      };
+    },
+    planMessages({
+      conversationId = null,
+      trigger = 'conversation_started',
+      turnIndex = 0,
+      remainingTurns = null,
+      worldRules = {},
+      previousState = null,
+      nextState = null,
+      emittedRuleIds = [],
+    } = {}) {
+      const resolvedConversationId = normalizeText(conversationId, null);
+      const messages = [];
+      const emitted = new Set(emittedRuleIds);
+
+      if (trigger === 'conversation_started' && worldRules.openingSystemMessage !== false) {
+        messages.push(
+          buildMessage({
+            conversationId: resolvedConversationId,
+            trigger,
+            templateRef: worldRules.openingTemplateRef || templateRefs.opening,
+            text: worldRules.openingText || null,
+            metadata: { phase: 'opening' },
+          }),
+        );
+      }
+
+      const rules = Array.isArray(worldRules.turnMessageRules)
+        ? worldRules.turnMessageRules.map((rule, index) => normalizeTurnRule(rule, index))
+        : [];
+      if (trigger === 'turn_threshold') {
+        for (const rule of rules) {
+          if (rule.trigger !== 'turn_threshold') continue;
+          if (rule.atTurn == null || turnIndex < rule.atTurn) continue;
+          if (rule.once && emitted.has(rule.id)) continue;
+          messages.push(
+            buildMessage({
+              conversationId: resolvedConversationId,
+              trigger,
+              role: rule.role,
+              visibility: rule.visibility,
+              templateRef: rule.templateRef,
+              text: rule.text,
+              metadata: { ruleId: rule.id, atTurn: rule.atTurn },
+            }),
+          );
+          emitted.add(rule.id);
+        }
+      }
+
+      const convergenceThreshold = Number.isFinite(Number(worldRules.convergence?.whenRemainingTurnsLTE))
+        ? Number(worldRules.convergence.whenRemainingTurnsLTE)
+        : 1;
+      if (
+        trigger === 'convergence' &&
+        remainingTurns != null &&
+        Number(remainingTurns) <= convergenceThreshold
+      ) {
+        messages.push(
+          buildMessage({
+            conversationId: resolvedConversationId,
+            trigger,
+            templateRef: worldRules.convergence?.templateRef || templateRefs.convergence,
+            text: worldRules.convergence?.text || null,
+            metadata: { remainingTurns: Number(remainingTurns) },
+          }),
+        );
+      }
+
+      if (trigger === 'state_changed' && previousState !== nextState && nextState) {
+        const stateKey = `${previousState || 'unknown'}_to_${nextState}`;
+        messages.push(
+          buildMessage({
+            conversationId: resolvedConversationId,
+            trigger,
+            templateRef:
+              worldRules.stateChangeMessages?.[stateKey]?.templateRef || templateRefs.stateChanged,
+            text: worldRules.stateChangeMessages?.[stateKey]?.text || null,
+            metadata: {
+              previousState,
+              nextState,
+              stateKey,
+            },
+          }),
+        );
+      }
+
+      return {
+        conversationId: resolvedConversationId,
+        turnIndex,
+        trigger,
+        emittedRuleIds: [...emitted],
+        messages,
+        status: messages.length > 0 ? 'planned' : 'noop',
+      };
+    },
+  };
+}

package/src/product-shell/results/result-service.js

@@ -3,13 +3,19 @@ import { createCanonicalResultBuilder } from '../../openclaw/runtime/canonical-r
 export function createResultService({ builder = createCanonicalResultBuilder() } = {}) {
   return {
     schema: builder.schema,
-    preview({ world, sessionId = 'ses_preview' } = {}) {
-      return builder.build({
-        sessionId,
+    previewConversation({ world, conversationKey = 'cnv_preview' } = {}) {
+      const preview = builder.build({
+        conversationId: conversationKey,
         intentSignals: world.resultContract.exampleSignals.intentSignals,
         conversationSignals: world.resultContract.exampleSignals.conversationSignals,
         agentSignals: world.resultContract.exampleSignals.agentSignals,
       });
+      const rest = { ...preview };
+      delete rest.conversationId;
+      return {
+        ...rest,
+        conversationKey,
+      };
     },
   };
 }

package/src/product-shell/search/search-service.js

@@ -37,6 +37,16 @@ function normalizeComparableText(value) {
   return normalizeText(value, null)?.toLowerCase() || null;
 }
 
+function tokenizeText(value) {
+  return [...new Set(
+    String(value || '')
+      .toLowerCase()
+      .split(/[^a-z0-9\u4e00-\u9fff]+/i)
+      .map((entry) => entry.trim())
+      .filter((entry) => entry.length >= 2),
+  )];
+}
+
 function normalizeSearchLimit(limit, fallback = 10) {
   const normalized = normalizeInteger(limit, fallback);
   if (normalized <= 0) return fallback;
@@ -133,6 +143,23 @@ function compareField(field, queryValue, candidateValue, worldId) {
 
   const weights = resolveFieldWeight(worldId, field);
 
+  if (field.fieldId === 'participantContextText') {
+    const queryTokens = tokenizeText(queryValue);
+    const candidateTokens = tokenizeText(candidateValue);
+    const sharedValues = queryTokens.filter((entry) => candidateTokens.includes(entry));
+    if (sharedValues.length === 0) return null;
+
+    return {
+      fieldId: field.fieldId,
+      label: field.label,
+      matchType: 'overlap',
+      queryValue: normalizeText(queryValue, ''),
+      candidateValue: normalizeText(candidateValue, ''),
+      sharedValues,
+      contribution: Math.min(sharedValues.length * 8, 48),
+    };
+  }
+
   if (field.type === 'string[]') {
     const queryItems = normalizeStringList(queryValue);
     const candidateItems = normalizeStringList(candidateValue);
@@ -180,7 +207,7 @@ function projectSummaryField(field, profile = {}) {
 function projectProfileSummary(world, profile = {}, agent = null) {
   return {
     displayName: normalizeText(agent?.displayName, null),
-    headline: normalizeText(profile.headline, null),
+    headline: normalizeText(profile.participantContextText, normalizeText(profile.headline, null)),
     requiredFields: world.joinSchema.requiredFields
       .map((field) => projectSummaryField(field, profile))
       .filter(Boolean),

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

@@ -57,7 +57,6 @@ export function registerChatRequestRoutes(app, { chatRequestService, store }) {
         kickoffBrief: req.body?.kickoffBrief,
         openingMessage: req.body?.openingMessage,
         worldId: req.body?.worldId,
-        episodePolicy: req.body?.episodePolicy,
       });
       res.status(201).json(result);
     } catch (error) {

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

@@ -1,5 +1,5 @@
 import { normalizeAgentProfile, resolveAgentDisplayName, resolveAgentVisibility } from '../../lib/agent-profile.js';
-import { createKickoffBrief, resolveStoredKickoffBrief } from '../../lib/accepted-chat-kickoff.js';
+import { createKickoffBrief, resolveStoredKickoffBrief } from '../../lib/relay/kickoff-text.js';
 import { WORLD_ACTIONS } from '../worlds/world-authorization.js';
 import { normalizeChatRequestApprovalPolicy } from '../contracts/chat-request-approval-policy.js';
 import {
@@ -39,87 +39,6 @@ function normalizeConversationWorldId(value) {
   return normalizeText(value, null);
 }
 
-function parseEpisodePolicy(episodePolicy = null) {
-  if (episodePolicy == null) return { value: null, error: null };
-  if (!episodePolicy || typeof episodePolicy !== 'object' || Array.isArray(episodePolicy)) {
-    return {
-      value: null,
-      error: {
-        code: 'chat_request_episode_policy_invalid',
-        message: 'episodePolicy must be an object',
-      },
-    };
-  }
-
-  const hasMaxTurns = Object.prototype.hasOwnProperty.call(episodePolicy, 'maxTurns');
-  const hasTurnTimeoutMs = Object.prototype.hasOwnProperty.call(episodePolicy, 'turnTimeoutMs');
-  const hasRaiseHandPolicy = Object.prototype.hasOwnProperty.call(episodePolicy, 'raiseHandPolicy');
-
-  const maxTurns = !hasMaxTurns
-    ? null
-    : episodePolicy.maxTurns === null
-      ? null
-      : normalizePositiveInteger(episodePolicy.maxTurns, null);
-  if (hasMaxTurns && episodePolicy.maxTurns != null && maxTurns == null) {
-    return {
-      value: null,
-      error: {
-        code: 'chat_request_episode_policy_invalid',
-        message: 'episodePolicy.maxTurns must be a positive integer',
-      },
-    };
-  }
-
-  const turnTimeoutMs = !hasTurnTimeoutMs
-    ? null
-    : episodePolicy.turnTimeoutMs === null
-      ? null
-      : normalizePositiveInteger(episodePolicy.turnTimeoutMs, null);
-  if (hasTurnTimeoutMs && episodePolicy.turnTimeoutMs != null && turnTimeoutMs == null) {
-    return {
-      value: null,
-      error: {
-        code: 'chat_request_episode_policy_invalid',
-        message: 'episodePolicy.turnTimeoutMs must be a positive integer',
-      },
-    };
-  }
-
-  if (
-    hasRaiseHandPolicy
-    && episodePolicy.raiseHandPolicy != null
-    && (
-      typeof episodePolicy.raiseHandPolicy !== 'object'
-      || Array.isArray(episodePolicy.raiseHandPolicy)
-    )
-  ) {
-    return {
-      value: null,
-      error: {
-        code: 'chat_request_episode_policy_invalid',
-        message: 'episodePolicy.raiseHandPolicy must be an object',
-      },
-    };
-  }
-
-  const raiseHandPolicy = cloneJsonObject(episodePolicy.raiseHandPolicy);
-  const value = {
-    ...(maxTurns != null ? { maxTurns } : {}),
-    ...(turnTimeoutMs != null ? { turnTimeoutMs } : {}),
-    ...(raiseHandPolicy ? { raiseHandPolicy } : {}),
-  };
-
-  return {
-    value: Object.keys(value).length > 0 ? value : null,
-    error: null,
-  };
-}
-
-function projectEpisodePolicy(conversation = {}) {
-  const parsed = parseEpisodePolicy(conversation);
-  return parsed.error ? null : parsed.value;
-}
-
 function sortByRecency(items = [], ...fieldNames) {
   return items.slice().sort((left, right) => {
     for (const fieldName of fieldNames) {
@@ -267,8 +186,6 @@ function projectKickoff(kickoff = {}) {
   return {
     status: normalizeText(kickoff.status, 'skipped'),
     deliveredAt: normalizeText(kickoff.deliveredAt, null),
-    relaySessionPreparedAt: normalizeText(kickoff.relaySessionPreparedAt, null),
-    acceptedRoundPreparedAt: normalizeText(kickoff.acceptedRoundPreparedAt, null),
     senderKickoffDeliveredAt: normalizeText(kickoff.senderKickoffDeliveredAt, normalizeText(kickoff.deliveredAt, null)),
     openerAcceptedAt: normalizeText(kickoff.openerAcceptedAt, null),
     openerDeliveredAt: normalizeText(kickoff.openerDeliveredAt, null),
@@ -399,8 +316,6 @@ export function createChatRequestService({
       : {};
     const worldId = normalizeConversationWorldId(conversation.worldId)
       || normalizeConversationWorldId(requestContext.conversation?.worldId);
-    const episodePolicy = projectEpisodePolicy(conversation)
-      || projectEpisodePolicy(requestContext.conversation || {});
     const counterpartyAgentId =
       viewerAgentId === request.fromAgentId
         ? request.toAgentId
@@ -430,7 +345,6 @@ export function createChatRequestService({
         mode: worldId ? 'world' : 'direct',
         worldId,
         world: projectWorldSummary(worldService, worldId),
-        ...(episodePolicy ? { episodePolicy } : {}),
       },
     };
   }
@@ -474,7 +388,6 @@ export function createChatRequestService({
       openingMessage = null,
       openingPayload = null,
       worldId = null,
-      episodePolicy = null,
       origin = null,
       broadcast = null,
       source = 'chat_request',
@@ -505,20 +418,7 @@ export function createChatRequestService({
       });
       const normalizedOrigin = normalizeChatRequestOrigin(origin);
       const normalizedBroadcast = normalizeChatRequestBroadcastMetadata(broadcast);
-      const normalizedEpisodePolicy = parseEpisodePolicy(episodePolicy);
-      if (normalizedEpisodePolicy.error) {
-        throw createInvalidChatRequestError(
-          normalizedEpisodePolicy.error.code,
-          normalizedEpisodePolicy.error.message,
-        );
-      }
       if (normalizedWorldId) {
-        if (normalizedEpisodePolicy.value) {
-          throw createInvalidChatRequestError(
-            'world_chat_request_episode_policy_not_supported',
-            'world-scoped chat requests inherit episode policy from the world template',
-          );
-        }
         worldService?.requireWorld?.(normalizedWorldId);
         if (normalizeText(source, 'chat_request') !== 'world_broadcast') {
           const authorization = worldAuthorizationService.evaluateWorldAction({
@@ -543,7 +443,6 @@ export function createChatRequestService({
         openingPayload: cloneJsonObject(normalizedKickoffBrief?.payload) || normalizedOpeningPayload,
         conversation: {
           ...(normalizedWorldId ? { worldId: normalizedWorldId } : {}),
-          ...(normalizedEpisodePolicy.value || {}),
         },
         origin: normalizedOrigin,
         broadcast: normalizedBroadcast,