@xfxstudio/claworld 0.1.5 → 0.2.1

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

@@ -1,21 +1,10 @@
-import {
-  buildWorldJoinOutcomeOrchestration,
-  buildWorldProfileCollectionFlow,
-} from '../contracts/world-orchestration.js';
+import { buildResolvedWorldJoinOrchestration } from '../contracts/world-orchestration.js';
+import { buildParticipantContextText } from '../worlds/world-text.js';
 
-function isEmptyValue(value) {
-  if (value == null) return true;
-  if (typeof value === 'string') return value.trim() === '';
-  if (Array.isArray(value)) return value.length === 0;
-  return false;
-}
-
-function projectMissingField(field = {}) {
-  return {
-    fieldId: field.fieldId,
-    label: field.label,
-    description: field.description,
-  };
+function normalizeText(value, fallback = null) {
+  if (value == null) return fallback;
+  const normalized = String(value).trim();
+  return normalized || fallback;
 }
 
 function createConfigurationError() {
@@ -49,67 +38,30 @@ function createInvalidJoinRequestError(fieldId, message = `${fieldId} is require
   return error;
 }
 
-function createMembershipNotEligibleError(joinCheck) {
-  const error = new Error('membership_not_eligible');
-  error.code = 'membership_not_eligible';
-  error.status = 422;
-  error.responseBody = {
-    error: error.code,
-    message: 'profile does not satisfy world join requirements',
-    joinCheck,
-    profileCollectionFlow: joinCheck.profileCollectionFlow || null,
-  };
-  return error;
-}
-
-function createJoinNotEligibleError(joinCheck) {
-  const error = new Error('world_join_not_eligible');
-  error.code = 'world_join_not_eligible';
-  error.status = 422;
-  error.responseBody = {
-    error: error.code,
-    message: 'profile does not satisfy world join requirements',
-    status: 'needs_profile',
-    membershipStatus: 'inactive',
-    worldId: joinCheck.worldId,
-    normalizedProfile: joinCheck.normalizedProfile,
-    missingFields: joinCheck.missingFields,
-    nextMissingField: joinCheck.nextMissingField,
-    missingFieldGuidance: joinCheck.missingFieldGuidance,
-    nextAction: 'retry_join_world_after_profile_update',
-  };
-  return error;
-}
-
 function normalizeAgentId(agentId) {
   const normalized = String(agentId || '').trim();
   return normalized || null;
 }
 
-function normalizeProfileSnapshot(...candidates) {
-  for (const candidate of candidates) {
-    if (candidate && typeof candidate === 'object' && !Array.isArray(candidate)) {
-      return candidate;
-    }
+function normalizeProfileSnapshot(profileSnapshot = null, participantContextText = null) {
+  const base = profileSnapshot && typeof profileSnapshot === 'object' && !Array.isArray(profileSnapshot)
+    ? { ...profileSnapshot }
+    : {};
+  const normalizedParticipantContextText = normalizeText(
+    participantContextText,
+    normalizeText(base.participantContextText, null),
+  );
+  if (normalizedParticipantContextText) {
+    base.participantContextText = normalizedParticipantContextText;
   }
-  return {};
+  return base;
 }
 
-function buildNextStageSummary(world) {
-  const matchingSummary = world.matching.strategySummary
-    || `The world uses ${world.matching.mode} matching to deliver candidate summaries before request_chat.`;
-  const reviewSummary =
-    'Review the backend-authored candidate feed, choose a candidate, and create a world-scoped chat request.';
-  const sessionSummary = `Matched agents then enter a ${world.sessionTemplate.mode} session with up to ${world.sessionTemplate.maxTurns} turns.`;
-
+function buildNextStageSummary() {
   return {
-    stage: 'matchmaking',
-    summary: `${matchingSummary} ${reviewSummary} ${sessionSummary}`.trim(),
-    matchingMode: world.matching.mode,
-    matchingCadence: world.matching.cadence,
-    sessionMode: world.sessionTemplate.mode,
-    maxTurns: world.sessionTemplate.maxTurns,
-    turnTimeoutMs: world.sessionTemplate.turnTimeoutMs,
+    stage: 'candidate_review',
+    summary:
+      'Review the backend-authored candidate feed or use world search, then choose one target agent and create a world-scoped chat request.',
   };
 }
 
@@ -119,67 +71,86 @@ export function createMembershipService({ worldService, store = null } = {}) {
     return store;
   }
 
+  function resolveNormalizedParticipantContextText({ participantContextText = null, profileSnapshot = null, agent = null, world = null } = {}) {
+    return buildParticipantContextText({
+      world,
+      agent,
+      participantContextText,
+      profileSnapshot,
+    });
+  }
+
   return {
-    evaluateJoin({ worldId, profile = {}, maxFieldsPerStep = 1 } = {}) {
+    evaluateJoin({ worldId, participantContextText = null } = {}) {
       const world = worldService.requireWorld(worldId);
-      const normalizedProfile = profile && typeof profile === 'object' ? profile : {};
-      const orderedMissingFields = world.joinSchema.requiredFields.filter((field) =>
-        isEmptyValue(normalizedProfile[field.fieldId]),
-      );
-      const missingFields = orderedMissingFields.map((field) => projectMissingField(field));
-      const nextMissingField = missingFields[0] || null;
+      const normalizedParticipantContextText = normalizeText(participantContextText, null);
+      const accepted = Boolean(normalizedParticipantContextText);
 
-      const joinCheck = {
+      return {
         worldId: world.worldId,
-        accepted: missingFields.length === 0,
-        status: missingFields.length === 0 ? 'eligible' : 'needs_profile',
-        missingFields,
-        nextMissingField,
+        accepted,
+        status: accepted ? 'eligible' : 'needs_profile',
+        participantContextText: normalizedParticipantContextText,
+        missingFields: accepted
+          ? []
+          : [
+            {
+              fieldId: 'participantContextText',
+              label: 'Entry Profile',
+              description: 'A short text describing who you are in this world and what context you bring into it.',
+            },
+          ],
+        nextMissingField: accepted
+          ? null
+          : {
+            fieldId: 'participantContextText',
+            label: 'Entry Profile',
+            description: 'A short text describing who you are in this world and what context you bring into it.',
+          },
         missingFieldGuidance: {
-          mode: nextMissingField ? 'ordered_required_fields' : 'complete',
-          orderedMissingFields: missingFields,
-          orderedMissingFieldIds: missingFields.map((field) => field.fieldId),
-          nextMissingField,
-          remainingRequiredFieldCount: missingFields.length,
+          mode: accepted ? 'complete' : 'single_text_field',
+          orderedMissingFields: accepted
+            ? []
+            : [
+              {
+                fieldId: 'participantContextText',
+                label: 'Entry Profile',
+                description: 'A short text describing who you are in this world and what context you bring into it.',
+              },
+            ],
+          orderedMissingFieldIds: accepted ? [] : ['participantContextText'],
+          nextMissingField: accepted
+            ? null
+            : {
+              fieldId: 'participantContextText',
+              label: 'Entry Profile',
+              description: 'A short text describing who you are in this world and what context you bring into it.',
+            },
+          remainingRequiredFieldCount: accepted ? 0 : 1,
         },
-        normalizedProfile,
-        nextAction:
-          missingFields.length === 0 ? 'call_join_world' : 'retry_join_world_after_profile_update',
-      };
-
-      const worldDetail = worldService.describeWorldDetail(world.worldId);
-      return {
-        ...joinCheck,
-        profileCollectionFlow: buildWorldProfileCollectionFlow({
-          worldDetail,
-          joinCheck,
-          profile: normalizedProfile,
-          maxFieldsPerStep,
-        }),
+        nextAction: accepted ? 'call_join_world' : 'retry_join_world_after_profile_update',
       };
     },
-    async createMembership({ worldId, agentId, profileSnapshot } = {}) {
-      worldService.requireWorld(worldId);
+
+    async createMembership({ worldId, agentId, participantContextText } = {}) {
+      const world = worldService.requireWorld(worldId);
       const membershipStore = assertStore();
       const normalizedAgentId = normalizeAgentId(agentId);
-      if (!normalizedAgentId) {
-        throw createInvalidJoinRequestError('agentId');
-      }
+      if (!normalizedAgentId) throw createInvalidJoinRequestError('agentId');
 
       const agent = membershipStore.getAgent(normalizedAgentId);
+      if (!agent) throw createAgentNotFoundError(normalizedAgentId);
 
-      if (!agent) {
-        throw createAgentNotFoundError(normalizedAgentId);
-      }
-
-      const normalizedProfileSnapshot = normalizeProfileSnapshot(profileSnapshot, agent.profile);
-      const joinCheck = this.evaluateJoin({
-        worldId,
-        profile: normalizedProfileSnapshot,
+      const normalizedParticipantContextText = resolveNormalizedParticipantContextText({
+        world,
+        agent,
+        participantContextText,
       });
-
-      if (!joinCheck.accepted) {
-        throw createMembershipNotEligibleError(joinCheck);
+      if (!normalizedParticipantContextText) {
+        throw createInvalidJoinRequestError(
+          'participantContextText',
+          'participantContextText is required',
+        );
       }
 
       const existingMembership = membershipStore.listMemberships({
@@ -195,34 +166,37 @@ export function createMembershipService({ worldService, store = null } = {}) {
         worldId,
         agentId: normalizedAgentId,
         status: 'joined',
-        profileSnapshot: joinCheck.normalizedProfile,
+        profileSnapshot: normalizeProfileSnapshot(null, normalizedParticipantContextText),
+        participantContextText: normalizedParticipantContextText,
       });
 
       return { membership, created: true };
     },
-    async joinWorld({ worldId, agentId, profile, profileSnapshot, maxFieldsPerStep = 1 } = {}) {
+
+    async joinWorld({
+      worldId,
+      agentId,
+      participantContextText,
+    } = {}) {
       const world = worldService.requireWorld(worldId);
       const membershipStore = assertStore();
       const normalizedAgentId = normalizeAgentId(agentId);
 
-      if (!normalizedAgentId) {
-        throw createInvalidJoinRequestError('agentId');
-      }
+      if (!normalizedAgentId) throw createInvalidJoinRequestError('agentId');
 
       const agent = membershipStore.getAgent(normalizedAgentId);
-      if (!agent) {
-        throw createAgentNotFoundError(normalizedAgentId);
-      }
+      if (!agent) throw createAgentNotFoundError(normalizedAgentId);
 
-      const effectiveProfile = normalizeProfileSnapshot(profile, profileSnapshot, agent.profile);
-      const joinCheck = this.evaluateJoin({
-        worldId: world.worldId,
-        profile: effectiveProfile,
-        maxFieldsPerStep,
+      const normalizedParticipantContextText = resolveNormalizedParticipantContextText({
+        world,
+        agent,
+        participantContextText,
       });
-
-      if (!joinCheck.accepted) {
-        throw createJoinNotEligibleError(joinCheck);
+      if (!normalizedParticipantContextText) {
+        throw createInvalidJoinRequestError(
+          'participantContextText',
+          'participantContextText is required',
+        );
       }
 
       const existingMembership = membershipStore.listMemberships({
@@ -233,49 +207,53 @@ export function createMembershipService({ worldService, store = null } = {}) {
       const membership = existingMembership
         ? await membershipStore.updateMembership(existingMembership.membershipId, {
           status: 'active',
-          profileSnapshot: joinCheck.normalizedProfile,
+          profileSnapshot: normalizeProfileSnapshot(existingMembership.profileSnapshot, normalizedParticipantContextText),
+          participantContextText: normalizedParticipantContextText,
         })
         : await membershipStore.createMembership({
           worldId: world.worldId,
           agentId: normalizedAgentId,
           status: 'active',
-          profileSnapshot: joinCheck.normalizedProfile,
+          profileSnapshot: normalizeProfileSnapshot(null, normalizedParticipantContextText),
+          participantContextText: normalizedParticipantContextText,
         });
 
-      return {
+      const joinResult = {
         status: 'joined',
         worldId: world.worldId,
         membership,
         membershipStatus: membership.status,
         created: !existingMembership,
-        normalizedProfile: joinCheck.normalizedProfile,
+        participantContextText: normalizedParticipantContextText,
         nextAction: 'review_candidate_feed',
-        nextStageSummary: buildNextStageSummary(world),
-        orchestration: buildWorldJoinOutcomeOrchestration({
-          worldDetail: worldService.describeWorldDetail(world.worldId),
-          joinResult: {
-            membershipStatus: membership.status,
-            membership,
-            normalizedProfile: joinCheck.normalizedProfile,
-            nextAction: 'review_candidate_feed',
-            nextStageSummary: buildNextStageSummary(world),
-          },
-        }),
+        nextStageSummary: buildNextStageSummary(),
+      };
+
+      return {
+        ...joinResult,
+        orchestration: buildResolvedWorldJoinOrchestration({
+          joinResult,
+          candidateDelivery: null,
+        }) || null,
       };
     },
+
     getMembership({ worldId, agentId, includeDisabled = false } = {}) {
       const normalizedAgentId = normalizeAgentId(agentId);
       if (!normalizedAgentId) return null;
       worldService.requireWorld(worldId, { includeDisabled });
       return assertStore().listMemberships({ worldId, agentId: normalizedAgentId })[0] || null;
     },
+
     listMemberships({ worldId, agentId = null, status = null, includeDisabled = false } = {}) {
       worldService.requireWorld(worldId, { includeDisabled });
       return assertStore().listMemberships({ worldId, agentId, status });
     },
+
     listMembershipsAcrossWorlds({ agentId = null, status = null } = {}) {
       return assertStore().listMemberships({ agentId, status });
     },
+
     countMemberships({ worldId, agentId = null, status = null, includeDisabled = false } = {}) {
       worldService.requireWorld(worldId, { includeDisabled });
       return assertStore().countMemberships({ worldId, agentId, status });

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

@@ -9,7 +9,7 @@ import {
 
 const DEFAULT_INSTALL_CHANNEL_ID = 'claworld';
 const DEFAULT_INSTALL_ACCOUNT_ID = 'claworld';
-const DEFAULT_INSTALL_LOCAL_AGENT_ID = 'claworld';
+const DEFAULT_INSTALL_LOCAL_AGENT_ID = 'main';
 const DEFAULT_ACTIVATION_DISPLAY_NAME = 'Claworld Agent';
 
 function normalizeText(value, fallback = null) {
@@ -174,7 +174,7 @@ export function createOnboardingService({ worldService, store = null } = {}) {
           `run ${CLAWORLD_INSTALLER_COMMAND}`,
           'installer validates OpenClaw availability and minimum host version',
           'installer verifies or installs the claworld OpenClaw plugin package',
-          'installer writes or refreshes the managed claworld channel config',
+          'installer writes or refreshes the managed claworld channel config and binds it to the local main agent by default',
           'installer calls POST /v1/onboarding/activate to obtain agentId and appToken when reuse is not possible',
           'installer persists the returned appToken into the managed claworld account config',
           'installer reloads or starts the runtime and verifies the relay binding',

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

@@ -0,0 +1,30 @@
+import { createSystemMessageOrchestrator } from './world-conversation-text.js';
+
+export function createWorldConversationOrchestrator({
+  worldService,
+  resultService,
+  systemMessages = createSystemMessageOrchestrator(),
+} = {}) {
+  return {
+    previewConversation({ worldId, conversationKey = 'cnv_preview' } = {}) {
+      const world = worldService.requireWorld(worldId);
+      const openingPlan = systemMessages.planMessages({
+        conversationId: conversationKey,
+        trigger: 'conversation_started',
+        worldRules: world.conversationTemplate.worldRules,
+      });
+      const convergencePlan = [];
+
+      return {
+        worldId: world.worldId,
+        conversationTemplate: {
+          mode: world.conversationTemplate.mode,
+        },
+        openingPlan,
+        convergencePlan,
+        resultPreview: resultService.previewConversation({ world, conversationKey }),
+        status: 'preview_ready',
+      };
+    },
+  };
+}

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,
+      };
     },
   };
 }