@xfxstudio/claworld 0.2.13 → 0.2.14

package/src/product-shell/contracts/world-manifest.js

@@ -1,369 +0,0 @@
-import { projectCandidateFeedModel } from './candidate-feed.js';
-import { buildWorldSessionStartupText } from './world-orchestration.js';
-import { buildWorldContextText } from '../worlds/world-text.js';
-
-function normalizeText(value, fallback = null) {
-  if (value == null) return fallback;
-  const normalized = String(value).trim();
-  return normalized || fallback;
-}
-
-function normalizeStringList(values = []) {
-  if (!Array.isArray(values)) return [];
-  return [...new Set(values.map((value) => normalizeText(value, null)).filter(Boolean))];
-}
-
-function normalizeCandidateSource(value) {
-  const normalized = normalizeText(value, null);
-  if (!normalized) return null;
-  if (
-    normalized === 'active_memberships'
-    || normalized === 'world_members'
-    || normalized === 'search_results'
-  ) {
-    return 'active_memberships_online';
-  }
-  return normalized;
-}
-
-function normalizeCandidateSources(values = []) {
-  if (!Array.isArray(values)) return [];
-  return [...new Set(values.map((value) => normalizeCandidateSource(value)).filter(Boolean))];
-}
-
-function normalizeWorldEligibility(value, fallback = 'active') {
-  const normalized = normalizeText(value, fallback);
-  if (normalized === 'joined') return 'joined';
-  return 'active';
-}
-
-function normalizeBroadcastAudience(value, fallback = 'members') {
-  const normalized = normalizeText(value, fallback);
-  if (normalized === 'admins') return 'admins';
-  if (normalized === 'admins_and_owner') return 'admins_and_owner';
-  return 'members';
-}
-
-function normalizeBroadcastReplyPolicy(value, fallback = 'zero') {
-  const normalized = normalizeText(value, fallback);
-  if (normalized === 'at_most_one') return 'at_most_one';
-  return 'zero';
-}
-
-function normalizeBroadcastConfig(broadcast = {}, { enabled = false } = {}) {
-  const normalized = broadcast && typeof broadcast === 'object' && !Array.isArray(broadcast)
-    ? broadcast
-    : {};
-
-  return {
-    enabled: normalized.enabled === true || enabled === true,
-    audience: normalizeBroadcastAudience(normalized.audience, 'members'),
-    replyPolicy: normalizeBroadcastReplyPolicy(normalized.replyPolicy, 'zero'),
-    excludeSelf: normalized.excludeSelf !== false,
-  };
-}
-
-function normalizeField(field = {}, index = 0, { required = false } = {}) {
-  const fieldId = normalizeText(field.fieldId || field.id, `field_${index + 1}`);
-  return {
-    fieldId,
-    label: normalizeText(field.label, fieldId),
-    type: normalizeText(field.type, 'string'),
-    source: normalizeText(field.source, 'profile'),
-    required: field.required === true || required,
-    description: normalizeText(field.description, null),
-    examples: normalizeStringList(field.examples),
-    constraints: field.constraints && typeof field.constraints === 'object' ? field.constraints : {},
-  };
-}
-
-function normalizeJoinSchema(joinSchema = {}) {
-  return {
-    requiredFields: [
-      {
-        fieldId: 'participantContextText',
-        label: 'Entry Profile',
-        type: 'string',
-        source: 'membership',
-        required: true,
-        description: 'Free-form participant profile/context text used for world join, search, and candidate review.',
-        examples: [],
-        constraints: {},
-      },
-    ],
-    optionalFields: [],
-    hints: [],
-  };
-}
-
-function normalizeSearchSchema(searchSchema = {}, joinSchema = {}) {
-  const fieldLookup = new Map(
-    [...joinSchema.requiredFields, ...joinSchema.optionalFields].map((field) => [field.fieldId, field]),
-  );
-  const rawInputFieldIds = Array.isArray(searchSchema.inputFieldIds)
-    ? searchSchema.inputFieldIds
-    : (Array.isArray(searchSchema.inputFields)
-      ? searchSchema.inputFields.map((field) => (typeof field === 'string' ? field : field.fieldId || field.id))
-      : joinSchema.requiredFields.map((field) => field.fieldId));
-  const inputFieldIds = normalizeStringList(rawInputFieldIds);
-  const inputFields = inputFieldIds.map((fieldId, index) => {
-    const referenced = fieldLookup.get(fieldId);
-    if (referenced) return { ...referenced };
-    return normalizeField({ fieldId, label: fieldId }, index, { required: false });
-  });
-
-  return {
-    mode: normalizeText(searchSchema.mode, 'membership_profile_search'),
-    inputFieldIds,
-    inputFields,
-    resultFields: normalizeStringList(
-      searchSchema.resultFields || [
-        'agentId',
-        'playerId',
-        'membershipId',
-        'worldId',
-        'displayName',
-        'headline',
-        'online',
-        'matchedFieldIds',
-        'score',
-        'profileSummary',
-      ],
-    ),
-    onlineOnly: searchSchema.onlineOnly !== false,
-    defaultLimit: Number.isFinite(Number(searchSchema.defaultLimit))
-      ? Math.max(1, Math.trunc(Number(searchSchema.defaultLimit)))
-      : 10,
-    summary: normalizeText(
-      searchSchema.summary,
-      'Compatibility-only manual search over active online world members. Candidate feed review is the canonical path before request_chat.',
-    ),
-    hints: normalizeStringList(searchSchema.hints),
-  };
-}
-
-function resolveConversationTemplateInput(manifest = {}) {
-  if (manifest.conversationTemplate && typeof manifest.conversationTemplate === 'object' && !Array.isArray(manifest.conversationTemplate)) {
-    return manifest.conversationTemplate;
-  }
-  return {};
-}
-
-export function normalizeWorldManifest(manifest = {}, index = 0) {
-  const worldId = normalizeText(manifest.worldId || manifest.id, `world_${index + 1}`);
-  const joinSchema = normalizeJoinSchema(manifest.joinSchema);
-  const searchSchema = normalizeSearchSchema(manifest.searchSchema, joinSchema);
-  const conversationTemplate = resolveConversationTemplateInput(manifest);
-  const defaultInteractionRules = normalizeText(conversationTemplate?.worldRules?.openingText, null);
-  const normalizedInteractionRules = normalizeText(manifest.interactionRules, defaultInteractionRules);
-  const normalizedProhibitedRules = normalizeText(manifest.prohibitedRules, null);
-
-  return {
-    worldId,
-    slug: normalizeText(manifest.slug, worldId),
-    displayName: normalizeText(manifest.displayName, worldId),
-    summary: normalizeText(manifest.summary, null),
-    description: normalizeText(manifest.description, normalizeText(manifest.summary, null)),
-    category: normalizeText(manifest.category, 'general'),
-    lifecycle: normalizeText(manifest.lifecycle, 'scaffold'),
-    tags: normalizeStringList(manifest.tags),
-    interactionRules: normalizedInteractionRules,
-    prohibitedRules: normalizedProhibitedRules,
-    worldContextText: buildWorldContextText({
-      worldId,
-      displayName: normalizeText(manifest.displayName, worldId),
-      summary: normalizeText(manifest.summary, null),
-      worldContextText: normalizeText(
-        manifest.worldContextText,
-        normalizeText(manifest.runtimeWorldContext?.text, null),
-      ),
-      interactionRules: normalizedInteractionRules,
-      prohibitedRules: normalizedProhibitedRules,
-    }),
-    creatorAgentId: normalizeText(manifest.creatorAgentId, null),
-    eligibility: normalizeWorldEligibility(manifest.eligibility, 'active'),
-    broadcast: normalizeBroadcastConfig(manifest.broadcast, {
-      enabled: manifest.broadcast?.enabled === true,
-    }),
-    status: normalizeText(manifest.status, manifest.enabled === true ? 'enabled' : 'draft'),
-    enabled: manifest.enabled === true,
-    schemaVersion: Number.isFinite(Number(manifest.schemaVersion)) ? Math.max(1, Math.trunc(Number(manifest.schemaVersion))) : 1,
-    createdAt: normalizeText(manifest.createdAt, null),
-    updatedAt: normalizeText(manifest.updatedAt, null),
-    metrics: manifest.metrics && typeof manifest.metrics === 'object'
-      ? {
-        totalConversationCount: Number.isFinite(Number(manifest.metrics.totalConversationCount))
-          ? Math.max(0, Math.trunc(Number(manifest.metrics.totalConversationCount)))
-          : 0,
-      }
-      : { totalConversationCount: 0 },
-    joinSchema,
-    searchSchema,
-    matching: {
-      mode: normalizeText(manifest.matching?.mode, 'manual_review'),
-      cadence: normalizeText(manifest.matching?.cadence, 'on_demand'),
-      strategySummary: normalizeText(manifest.matching?.strategySummary, null),
-      candidateSources: normalizeCandidateSources(manifest.matching?.candidateSources),
-    },
-    conversationTemplate: {
-      mode: normalizeText(conversationTemplate?.mode, 'a2a'),
-      worldRules: {
-        openingText: normalizeText(conversationTemplate?.worldRules?.openingText, null),
-        turnMessageRules: Array.isArray(conversationTemplate?.worldRules?.turnMessageRules)
-          ? conversationTemplate.worldRules.turnMessageRules
-          : [],
-        convergence: conversationTemplate?.worldRules?.convergence || {},
-        stateChangeMessages: conversationTemplate?.worldRules?.stateChangeMessages || {},
-      },
-    },
-    meta: {
-      status: normalizeText(manifest.meta?.status, 'scaffold_ready'),
-      persistence: normalizeText(manifest.meta?.persistence, 'in_memory_catalog'),
-    },
-  };
-}
-
-export function projectWorldCard(world) {
-  return {
-    worldId: world.worldId,
-    slug: world.slug,
-    displayName: world.displayName,
-    worldContextText: world.worldContextText,
-    createdAt: world.createdAt || null,
-    updatedAt: world.updatedAt || null,
-    status: world.status || world.meta.status,
-    enabled: world.enabled === true,
-  };
-}
-
-export function projectJoinPlan(world) {
-  return {
-    worldId: world.worldId,
-    participantContextField: {
-      fieldId: 'participantContextText',
-      label: 'Entry Profile',
-      description: 'A short text describing who you are in this world and what context you bring into it.',
-    },
-    nextAction: 'call_join_world',
-  };
-}
-
-function projectFieldGuide(fields = [], { required = false } = {}) {
-  return fields.map((field) => ({
-    fieldId: field.fieldId,
-    label: field.label,
-    required,
-    type: field.type,
-    source: field.source,
-    description: field.description,
-    examples: field.examples,
-    constraints: field.constraints,
-  }));
-}
-
-export function projectSearchModel(world) {
-  return {
-    modelId: `${world.worldId}.search.v1`,
-    worldId: world.worldId,
-    mode: world.searchSchema.mode,
-    previewRoute: `/v1/worlds/${world.worldId}/search`,
-    inputFieldIds: world.searchSchema.inputFieldIds,
-    inputFields: projectFieldGuide(world.searchSchema.inputFields, { required: false }),
-    resultFields: world.searchSchema.resultFields,
-    viewerRequirement: 'active_membership',
-    onlineOnly: world.searchSchema.onlineOnly,
-    defaultLimit: world.searchSchema.defaultLimit,
-    summary: world.searchSchema.summary,
-    hints: world.searchSchema.hints,
-    status: 'compatibility_world_search',
-  };
-}
-
-export function projectWorldDetail(world) {
-  const joinPlan = projectJoinPlan(world);
-  const worldContextText = normalizeText(
-    world.worldContextText,
-    buildWorldSessionStartupText({
-      worldId: world.worldId,
-      displayName: world.displayName,
-      summary: world.summary,
-      interactionRules: world.interactionRules,
-      prohibitedRules: world.prohibitedRules,
-      conversationMode: world.conversationTemplate.mode,
-      conversationOverview: {
-        worldId: world.worldId,
-        mode: world.conversationTemplate.mode,
-        openingText: world.conversationTemplate.worldRules.openingText,
-        convergence: world.conversationTemplate.worldRules.convergence,
-      },
-    }),
-  );
-
-  return {
-    worldId: world.worldId,
-    world: {
-      worldId: world.worldId,
-      displayName: world.displayName,
-      worldContextText,
-    },
-    management: {
-      ownerAgentId: world.creatorAgentId || null,
-      enabled: world.enabled === true,
-      status: world.status || world.meta.status,
-      createdAt: world.createdAt || null,
-      updatedAt: world.updatedAt || null,
-      memberCount: world.metrics?.memberCount || null,
-      totalConversationCount: Number.isFinite(Number(world.metrics?.totalConversationCount))
-        ? Math.max(0, Math.trunc(Number(world.metrics.totalConversationCount)))
-        : 0,
-    },
-    participantContextField: joinPlan.participantContextField,
-    joinPlan,
-    worldContextText,
-  };
-}
-
-export function projectConversationWorldContext(world) {
-  const runtimeWorldContext = {
-    worldId: world.worldId,
-    status: 'ready',
-    source: 'product_shell_conversation_world_context',
-    text: normalizeText(
-      world.worldContextText,
-      buildWorldSessionStartupText({
-        worldId: world.worldId,
-        displayName: world.displayName,
-        summary: world.summary,
-        interactionRules: world.interactionRules,
-        prohibitedRules: world.prohibitedRules,
-        conversationMode: world.conversationTemplate.mode,
-        conversationOverview: {
-          worldId: world.worldId,
-          mode: world.conversationTemplate.mode,
-          openingText: world.conversationTemplate.worldRules.openingText,
-          convergence: world.conversationTemplate.worldRules.convergence,
-        },
-      }),
-    ),
-  };
-
-  return {
-    worldId: world.worldId,
-    displayName: world.displayName,
-    summary: world.summary,
-    worldContextText: runtimeWorldContext.text,
-    interactionRules: world.interactionRules,
-    prohibitedRules: world.prohibitedRules,
-    conversationMode: world.conversationTemplate.mode,
-    conversationOverview: {
-      worldId: world.worldId,
-      mode: world.conversationTemplate.mode,
-      openingText: world.conversationTemplate.worldRules.openingText,
-      convergence: world.conversationTemplate.worldRules.convergence,
-      turnMessageRules: world.conversationTemplate.worldRules.turnMessageRules,
-    },
-    status: 'ready',
-    source: 'product_shell_conversation_world_context',
-    runtimeWorldContext,
-  };
-}

package/src/product-shell/conversation-feedback/conversation-feedback-service.js

@@ -1,261 +0,0 @@
-const FEEDBACK_TOKEN_TO_SENTIMENT = Object.freeze({
-  '[[like]]': 'like',
-  '[[dislike]]': 'dislike',
-});
-
-const SENTIMENT_VALUES = Object.freeze(['like', 'dislike']);
-
-function normalizeText(value, fallback = null) {
-  if (value == null) return fallback;
-  const normalized = String(value).trim();
-  return normalized || fallback;
-}
-
-function createConfigurationError() {
-  const error = new Error('conversation_feedback_store_unavailable');
-  error.code = 'conversation_feedback_store_unavailable';
-  error.status = 500;
-  return error;
-}
-
-function createInvalidConversationFeedbackError(fieldId, message = `${fieldId} is required`) {
-  const error = new Error(`invalid_conversation_feedback:${fieldId}`);
-  error.code = 'invalid_conversation_feedback';
-  error.status = 400;
-  error.responseBody = {
-    error: error.code,
-    message: 'conversation feedback request is invalid',
-    fieldErrors: [
-      {
-        fieldId,
-        message,
-      },
-    ],
-  };
-  return error;
-}
-
-function normalizeSentiment(value, fallback = null) {
-  const normalized = normalizeText(value, fallback);
-  return SENTIMENT_VALUES.includes(normalized) ? normalized : fallback;
-}
-
-function resolveSentimentFromToken(token = null) {
-  const normalizedToken = normalizeText(token, null);
-  return normalizedToken ? FEEDBACK_TOKEN_TO_SENTIMENT[normalizedToken] || null : null;
-}
-
-export function parseConversationFeedbackTokens(text = '') {
-  if (typeof text !== 'string' || !text.trim()) {
-    return {
-      tokens: [],
-      sentiment: null,
-      conflict: false,
-    };
-  }
-
-  const matches = [...text.matchAll(/\[\[(like|dislike)\]\]/g)];
-  if (matches.length === 0) {
-    return {
-      tokens: [],
-      sentiment: null,
-      conflict: false,
-    };
-  }
-
-  const tokens = [...new Set(matches.map((match) => `[[${String(match[1] || '').trim().toLowerCase()}]]`))];
-  const sentiments = [...new Set(tokens.map((token) => resolveSentimentFromToken(token)).filter(Boolean))];
-  return {
-    tokens,
-    sentiment: sentiments.length === 1 ? sentiments[0] : null,
-    conflict: sentiments.length > 1,
-  };
-}
-
-function projectFeedbackMark(feedbackMark = {}) {
-  return {
-    feedbackMarkId: normalizeText(feedbackMark.feedbackMarkId, null),
-    conversationKey: normalizeText(feedbackMark.conversationKey, null),
-    worldId: normalizeText(feedbackMark.worldId, null),
-    giverAgentId: normalizeText(feedbackMark.giverAgentId, null),
-    receiverAgentId: normalizeText(feedbackMark.receiverAgentId, null),
-    sourceTurnId: normalizeText(feedbackMark.sourceTurnId, null),
-    sourceDeliveryId: normalizeText(feedbackMark.sourceDeliveryId, null),
-    token: normalizeText(feedbackMark.token, null),
-    sentiment: normalizeSentiment(feedbackMark.sentiment, null),
-    source: normalizeText(feedbackMark.source, 'reply_control_token'),
-    status: normalizeText(feedbackMark.status, 'active'),
-    createdAt: normalizeText(feedbackMark.createdAt, null),
-    updatedAt: normalizeText(feedbackMark.updatedAt, normalizeText(feedbackMark.createdAt, null)),
-  };
-}
-
-function summarizeReceived(items = []) {
-  return {
-    likesReceived: items.filter((item) => item.sentiment === 'like').length,
-    dislikesReceived: items.filter((item) => item.sentiment === 'dislike').length,
-  };
-}
-
-export function createConversationFeedbackService({ store } = {}) {
-  if (
-    !store
-    || typeof store.createConversationFeedbackMark !== 'function'
-    || typeof store.listConversationFeedbackMarks !== 'function'
-    || typeof store.findConversationFeedbackMarkByConversationAndActors !== 'function'
-  ) {
-    throw createConfigurationError();
-  }
-
-  return {
-    parseTokens(text = '') {
-      return parseConversationFeedbackTokens(text);
-    },
-
-    async recordFeedback({
-      conversationKey,
-      worldId = null,
-      giverAgentId,
-      receiverAgentId,
-      sourceTurnId = null,
-      sourceDeliveryId = null,
-      token = null,
-      sentiment = null,
-    } = {}) {
-      const normalizedConversationKey = normalizeText(conversationKey, null);
-      if (!normalizedConversationKey) {
-        throw createInvalidConversationFeedbackError('conversationKey');
-      }
-      const normalizedGiverAgentId = normalizeText(giverAgentId, null);
-      if (!normalizedGiverAgentId) {
-        throw createInvalidConversationFeedbackError('giverAgentId');
-      }
-      const normalizedReceiverAgentId = normalizeText(receiverAgentId, null);
-      if (!normalizedReceiverAgentId) {
-        throw createInvalidConversationFeedbackError('receiverAgentId');
-      }
-      const normalizedToken = normalizeText(token, null);
-      const normalizedSentiment = normalizeSentiment(sentiment, resolveSentimentFromToken(normalizedToken));
-      if (!normalizedSentiment) {
-        throw createInvalidConversationFeedbackError('sentiment', 'sentiment must be like or dislike');
-      }
-
-      const existing = store.findConversationFeedbackMarkByConversationAndActors({
-        conversationKey: normalizedConversationKey,
-        giverAgentId: normalizedGiverAgentId,
-        receiverAgentId: normalizedReceiverAgentId,
-      });
-      if (existing) {
-        return {
-          recorded: false,
-          deduped: true,
-          feedbackMark: projectFeedbackMark(existing),
-        };
-      }
-
-      const feedbackMark = await store.createConversationFeedbackMark({
-        conversationKey: normalizedConversationKey,
-        worldId: normalizeText(worldId, null),
-        giverAgentId: normalizedGiverAgentId,
-        receiverAgentId: normalizedReceiverAgentId,
-        sourceTurnId: normalizeText(sourceTurnId, null),
-        sourceDeliveryId: normalizeText(sourceDeliveryId, null),
-        token: normalizedToken || `[[${normalizedSentiment}]]`,
-        sentiment: normalizedSentiment,
-        source: 'reply_control_token',
-        status: 'active',
-      });
-
-      return {
-        recorded: true,
-        deduped: false,
-        feedbackMark: projectFeedbackMark(feedbackMark),
-      };
-    },
-
-    listFeedbackMarks(filters = {}) {
-      return store.listConversationFeedbackMarks(filters).map((item) => projectFeedbackMark(item));
-    },
-
-    summarizeConversation({ conversationKey, viewerAgentId = null } = {}) {
-      const normalizedConversationKey = normalizeText(conversationKey, null);
-      const normalizedViewerAgentId = normalizeText(viewerAgentId, null);
-      const items = normalizedConversationKey
-        ? this.listFeedbackMarks({ conversationKey: normalizedConversationKey, status: 'active' })
-        : [];
-      const viewerGave = normalizedViewerAgentId
-        ? items.find((item) => item.giverAgentId === normalizedViewerAgentId)?.sentiment || null
-        : null;
-      const viewerReceived = normalizedViewerAgentId
-        ? items.find((item) => item.receiverAgentId === normalizedViewerAgentId)?.sentiment || null
-        : null;
-      return {
-        likeCount: items.filter((item) => item.sentiment === 'like').length,
-        dislikeCount: items.filter((item) => item.sentiment === 'dislike').length,
-        viewerGave,
-        viewerReceived,
-      };
-    },
-
-    summarizeAgent({ agentId } = {}) {
-      const normalizedAgentId = normalizeText(agentId, null);
-      if (!normalizedAgentId) {
-        return {
-          totalLikesReceived: 0,
-          totalDislikesReceived: 0,
-          totalLikesGiven: 0,
-          totalDislikesGiven: 0,
-        };
-      }
-      const received = this.listFeedbackMarks({
-        receiverAgentId: normalizedAgentId,
-        status: 'active',
-      });
-      const given = this.listFeedbackMarks({
-        giverAgentId: normalizedAgentId,
-        status: 'active',
-      });
-
-      return {
-        totalLikesReceived: received.filter((item) => item.sentiment === 'like').length,
-        totalDislikesReceived: received.filter((item) => item.sentiment === 'dislike').length,
-        totalLikesGiven: given.filter((item) => item.sentiment === 'like').length,
-        totalDislikesGiven: given.filter((item) => item.sentiment === 'dislike').length,
-      };
-    },
-
-    summarizeWorldAgent({ worldId, agentId } = {}) {
-      const normalizedWorldId = normalizeText(worldId, null);
-      const normalizedAgentId = normalizeText(agentId, null);
-      if (!normalizedWorldId || !normalizedAgentId) {
-        return {
-          likesReceived: 0,
-          dislikesReceived: 0,
-        };
-      }
-      return summarizeReceived(this.listFeedbackMarks({
-        worldId: normalizedWorldId,
-        receiverAgentId: normalizedAgentId,
-        status: 'active',
-      }));
-    },
-
-    summarizeWorld({ worldId } = {}) {
-      const normalizedWorldId = normalizeText(worldId, null);
-      if (!normalizedWorldId) {
-        return {
-          totalLikes: 0,
-          totalDislikes: 0,
-        };
-      }
-      const items = this.listFeedbackMarks({
-        worldId: normalizedWorldId,
-        status: 'active',
-      });
-      return {
-        totalLikes: items.filter((item) => item.sentiment === 'like').length,
-        totalDislikes: items.filter((item) => item.sentiment === 'dislike').length,
-      };
-    },
-  };
-}

package/src/product-shell/feedback/feedback-contract.js

@@ -1,13 +0,0 @@
-export const FEEDBACK_CATEGORY_VALUES = Object.freeze([
-  'experience_issue',
-  'usage_issue',
-  'bug_report',
-  'feature_request',
-]);
-
-export const FEEDBACK_IMPACT_VALUES = Object.freeze([
-  'low',
-  'medium',
-  'high',
-  'blocker',
-]);