@xfxstudio/claworld 0.2.23-beta.1 → 0.2.23-beta.2

package/openclaw.plugin.json

@@ -8,7 +8,7 @@
   ],
   "name": "Claworld Persona Relay",
   "description": "Claworld relay world channel plugin for OpenClaw.",
-  "version": "0.2.23-beta.1",
+  "version": "0.2.23-beta.2",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xfxstudio/claworld",
-  "version": "0.2.23-beta.1",
+  "version": "0.2.23-beta.2",
   "description": "Claworld channel plugin for OpenClaw",
   "type": "module",
   "main": "index.js",

package/src/lib/chat-request.js

@@ -1,4 +1,5 @@
 import { createKickoffBrief } from './relay/kickoff-text.js';
+import { normalizeAcceptedChatKickoffRecord } from './relay/kickoff-progress.js';
 
 function normalizeText(value, fallback = null) {
   if (value == null) return fallback;
@@ -358,7 +359,7 @@ export function normalizeStoredChatRequest(input = {}, { defaultSource = 'chat_r
   if (acceptedByAgentId) normalized.acceptedByAgentId = acceptedByAgentId;
   const approvalGrantId = normalizeText(input.approvalGrantId, null);
   if (approvalGrantId) normalized.approvalGrantId = approvalGrantId;
-  const kickoff = cloneJsonObject(input.kickoff);
+  const kickoff = normalizeAcceptedChatKickoffRecord(cloneJsonObject(input.kickoff));
   if (kickoff) normalized.kickoff = kickoff;
 
   return normalized;

package/src/lib/relay/kickoff-progress.js

@@ -0,0 +1,162 @@
+import { normalizeOptionalText } from './shared.js';
+
+function normalizeAcceptedChatKickoffField(value, fallback = null) {
+  return normalizeOptionalText(value) || fallback;
+}
+
+export function normalizeAcceptedChatKickoffRecord(kickoff = null, { fallbackStatus = null } = {}) {
+  if (!kickoff || typeof kickoff !== 'object' || Array.isArray(kickoff)) return null;
+
+  const normalized = {
+    ...kickoff,
+  };
+
+  const normalizedStatus = normalizeAcceptedChatKickoffField(normalized.status, fallbackStatus);
+  const normalizedReason = normalizeAcceptedChatKickoffField(normalized.reason, null);
+  const normalizedDeliveredAt = normalizeAcceptedChatKickoffField(normalized.deliveredAt, null);
+  const normalizedSenderKickoffDeliveredAt = normalizeAcceptedChatKickoffField(
+    normalized.senderKickoffDeliveredAt,
+    normalizedDeliveredAt,
+  );
+  const normalizedOpenerAcceptedAt = normalizeAcceptedChatKickoffField(normalized.openerAcceptedAt, null);
+  const normalizedOpenerDeliveredAt = normalizeAcceptedChatKickoffField(normalized.openerDeliveredAt, null);
+  const normalizedLiveChatEstablishedAt = normalizeAcceptedChatKickoffField(normalized.liveChatEstablishedAt, null);
+  const normalizedTurnId = normalizeAcceptedChatKickoffField(normalized.turnId, null);
+  const normalizedDeliveryId = normalizeAcceptedChatKickoffField(normalized.deliveryId, null);
+  const normalizedConversationKey = normalizeAcceptedChatKickoffField(normalized.conversationKey, null);
+  const normalizedOpenerTurnId = normalizeAcceptedChatKickoffField(normalized.openerTurnId, null);
+  const normalizedOpenerDeliveryId = normalizeAcceptedChatKickoffField(normalized.openerDeliveryId, null);
+  const normalizedFailedAt = normalizeAcceptedChatKickoffField(normalized.failedAt, null);
+
+  if (normalizedStatus) normalized.status = normalizedStatus;
+  else delete normalized.status;
+  if (normalizedReason) normalized.reason = normalizedReason;
+  else delete normalized.reason;
+  if (normalizedDeliveredAt) normalized.deliveredAt = normalizedDeliveredAt;
+  else delete normalized.deliveredAt;
+  if (normalizedSenderKickoffDeliveredAt) normalized.senderKickoffDeliveredAt = normalizedSenderKickoffDeliveredAt;
+  else delete normalized.senderKickoffDeliveredAt;
+  if (normalizedOpenerAcceptedAt) normalized.openerAcceptedAt = normalizedOpenerAcceptedAt;
+  else delete normalized.openerAcceptedAt;
+  if (normalizedOpenerDeliveredAt) normalized.openerDeliveredAt = normalizedOpenerDeliveredAt;
+  else delete normalized.openerDeliveredAt;
+  if (normalizedLiveChatEstablishedAt) normalized.liveChatEstablishedAt = normalizedLiveChatEstablishedAt;
+  else delete normalized.liveChatEstablishedAt;
+  if (normalizedTurnId) normalized.turnId = normalizedTurnId;
+  else delete normalized.turnId;
+  if (normalizedDeliveryId) normalized.deliveryId = normalizedDeliveryId;
+  else delete normalized.deliveryId;
+  if (normalizedConversationKey) normalized.conversationKey = normalizedConversationKey;
+  else delete normalized.conversationKey;
+  if (normalizedOpenerTurnId) normalized.openerTurnId = normalizedOpenerTurnId;
+  else delete normalized.openerTurnId;
+  if (normalizedOpenerDeliveryId) normalized.openerDeliveryId = normalizedOpenerDeliveryId;
+  else delete normalized.openerDeliveryId;
+  if (normalizedFailedAt) normalized.failedAt = normalizedFailedAt;
+  else delete normalized.failedAt;
+
+  const hasEstablishedEvidence = Boolean(
+    normalized.openerDeliveredAt
+    || normalized.liveChatEstablishedAt,
+  );
+
+  if (hasEstablishedEvidence && (!normalized.status || ['queued', 'sent'].includes(normalized.status))) {
+    normalized.status = 'established';
+  }
+
+  if (normalized.status === 'established') {
+    const establishedAt = normalizeAcceptedChatKickoffField(
+      normalized.liveChatEstablishedAt,
+      normalizeAcceptedChatKickoffField(
+        normalized.openerDeliveredAt,
+        normalizeAcceptedChatKickoffField(normalized.openerAcceptedAt, null),
+      ),
+    );
+    if (!normalized.openerDeliveredAt && normalized.openerAcceptedAt) {
+      normalized.openerDeliveredAt = normalized.openerAcceptedAt;
+    }
+    if (!normalized.liveChatEstablishedAt && establishedAt) {
+      normalized.liveChatEstablishedAt = establishedAt;
+    }
+    if (String(normalized.reason || '').startsWith('queued_')) {
+      delete normalized.reason;
+    }
+  }
+
+  return normalized;
+}
+
+export async function markAcceptedChatKickoffFailureWithDeps(deps, {
+  requestId = null,
+  reason = 'accepted_chat_kickoff_failed',
+  turnId = null,
+  conversationKey = null,
+} = {}) {
+  const { store, pushToAgent } = deps;
+  const normalizedRequestId = normalizeOptionalText(requestId);
+  if (!normalizedRequestId) return null;
+  const request = store.getChatRequest(normalizedRequestId);
+  if (!request) return null;
+
+  request.kickoff = normalizeAcceptedChatKickoffRecord({
+    ...(request.kickoff && typeof request.kickoff === 'object' && !Array.isArray(request.kickoff) ? request.kickoff : {}),
+    status: 'failed',
+    reason: normalizeOptionalText(reason) || 'accepted_chat_kickoff_failed',
+    ...(normalizeOptionalText(turnId) ? { turnId: normalizeOptionalText(turnId) } : {}),
+    ...(normalizeOptionalText(conversationKey) ? { conversationKey: normalizeOptionalText(conversationKey) } : {}),
+    failedAt: store.now(),
+  });
+  if (store.markChatRequestUpdated) {
+    await store.markChatRequestUpdated();
+  }
+  await pushToAgent(request.fromAgentId, 'request.updated', request);
+  await pushToAgent(request.toAgentId, 'request.updated', request);
+  return request;
+}
+
+export async function markAcceptedChatKickoffProgressWithDeps(deps, {
+  requestId = null,
+  status = null,
+  reason = null,
+  turnId = null,
+  deliveryId = null,
+  conversationKey = null,
+  senderKickoffDeliveredAt = null,
+  openerAcceptedAt = null,
+  openerDeliveredAt = null,
+  liveChatEstablishedAt = null,
+  openerTurnId = null,
+  openerDeliveryId = null,
+} = {}) {
+  const { store, pushToAgent } = deps;
+  const normalizedRequestId = normalizeOptionalText(requestId);
+  if (!normalizedRequestId) return null;
+  const request = store.getChatRequest(normalizedRequestId);
+  if (!request) return null;
+
+  request.kickoff = normalizeAcceptedChatKickoffRecord({
+    ...(request.kickoff && typeof request.kickoff === 'object' && !Array.isArray(request.kickoff) ? request.kickoff : {}),
+    ...(normalizeOptionalText(status) ? { status: normalizeOptionalText(status) } : {}),
+    ...(normalizeOptionalText(reason) ? { reason: normalizeOptionalText(reason) } : {}),
+    ...(normalizeOptionalText(turnId) ? { turnId: normalizeOptionalText(turnId) } : {}),
+    ...(normalizeOptionalText(deliveryId) ? { deliveryId: normalizeOptionalText(deliveryId) } : {}),
+    ...(normalizeOptionalText(conversationKey) ? { conversationKey: normalizeOptionalText(conversationKey) } : {}),
+    ...(normalizeOptionalText(senderKickoffDeliveredAt)
+      ? {
+          senderKickoffDeliveredAt: normalizeOptionalText(senderKickoffDeliveredAt),
+          deliveredAt: normalizeOptionalText(senderKickoffDeliveredAt),
+        }
+      : {}),
+    ...(normalizeOptionalText(openerAcceptedAt) ? { openerAcceptedAt: normalizeOptionalText(openerAcceptedAt) } : {}),
+    ...(normalizeOptionalText(openerDeliveredAt) ? { openerDeliveredAt: normalizeOptionalText(openerDeliveredAt) } : {}),
+    ...(normalizeOptionalText(liveChatEstablishedAt) ? { liveChatEstablishedAt: normalizeOptionalText(liveChatEstablishedAt) } : {}),
+    ...(normalizeOptionalText(openerTurnId) ? { openerTurnId: normalizeOptionalText(openerTurnId) } : {}),
+    ...(normalizeOptionalText(openerDeliveryId) ? { openerDeliveryId: normalizeOptionalText(openerDeliveryId) } : {}),
+  });
+  if (store.markChatRequestUpdated) {
+    await store.markChatRequestUpdated();
+  }
+  await pushToAgent(request.fromAgentId, 'request.updated', request);
+  await pushToAgent(request.toAgentId, 'request.updated', request);
+  return request;
+}

package/src/lib/relay/shared.js

@@ -0,0 +1,30 @@
+export function normalizePositiveInteger(value, fallback) {
+  const normalized = Number(value);
+  if (!Number.isFinite(normalized) || normalized <= 0) return fallback;
+  return Math.floor(normalized);
+}
+
+export function normalizeOptionalText(value) {
+  if (typeof value !== 'string') return null;
+  const normalized = value.trim();
+  return normalized || null;
+}
+
+export function cloneJsonObject(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  try {
+    const cloned = JSON.parse(JSON.stringify(value));
+    if (!cloned || typeof cloned !== 'object' || Array.isArray(cloned)) return null;
+    return cloned;
+  } catch {
+    return null;
+  }
+}
+
+export function buildFailureBody(reason, extras = {}) {
+  return {
+    error: reason,
+    reason,
+    ...extras,
+  };
+}

package/src/openclaw/plugin/claworld-channel-plugin.js

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import claworldPackageJson from '../../../package.json' with { type: 'json' };
 
 import {
   applyRuntimeIdentity,
@@ -57,6 +58,8 @@ import {
 } from '../../lib/runtime-errors.js';
 import { PUBLIC_IDENTITY_STATUS } from '../../lib/public-identity.js';
 
+const CLAWORLD_PLUGIN_VERSION = claworldPackageJson.version;
+
 function normalizeRelayHttpBaseUrl(serverUrl) {
   const parsed = new URL(serverUrl);
   if (parsed.protocol === 'ws:') parsed.protocol = 'http:';
@@ -2450,7 +2453,7 @@ export function createClaworldChannelPlugin({
     return {
       ok: true,
       pluginId: 'claworld',
-      version: '0.3.0',
+      version: CLAWORLD_PLUGIN_VERSION,
       defaultAccountId: null,
       accounts: accountSnapshots,
       relayClients: Object.fromEntries(
@@ -2599,7 +2602,7 @@ async function generateRuntimeProfileCard(context = {}) {
       docsPath: '/channels/claworld',
       docsLabel: 'claworld',
       blurb: 'Claworld relay channel backed by the Claworld backend.',
-      version: '0.3.0',
+      version: CLAWORLD_PLUGIN_VERSION,
       forceAccountBinding: true,
     },
     onboarding: claworldOnboardingAdapter,

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

@@ -1,3 +1,5 @@
+import { normalizeAcceptedChatKickoffRecord } from '../../lib/relay/kickoff-progress.js';
+
 function normalizeText(value, fallback = null) {
   if (value == null) return fallback;
   const normalized = String(value).trim();
@@ -437,15 +439,19 @@ function normalizeConversationScopeDetails(input = {}) {
 }
 
 function projectChatRequestKickoff(kickoff = {}) {
-  if (!kickoff || typeof kickoff !== 'object') return null;
+  const normalizedKickoff = normalizeAcceptedChatKickoffRecord(kickoff, { fallbackStatus: 'skipped' });
+  if (!normalizedKickoff) return null;
   return {
-    status: normalizeText(kickoff.status, 'skipped'),
-    deliveredAt: normalizeText(kickoff.deliveredAt, null),
-    senderKickoffDeliveredAt: normalizeText(kickoff.senderKickoffDeliveredAt, normalizeText(kickoff.deliveredAt, null)),
-    openerAcceptedAt: normalizeText(kickoff.openerAcceptedAt, null),
-    openerDeliveredAt: normalizeText(kickoff.openerDeliveredAt, null),
-    liveChatEstablishedAt: normalizeText(kickoff.liveChatEstablishedAt, null),
-    reason: normalizeText(kickoff.reason, null),
+    status: normalizeText(normalizedKickoff.status, 'skipped'),
+    deliveredAt: normalizeText(normalizedKickoff.deliveredAt, null),
+    senderKickoffDeliveredAt: normalizeText(
+      normalizedKickoff.senderKickoffDeliveredAt,
+      normalizeText(normalizedKickoff.deliveredAt, null),
+    ),
+    openerAcceptedAt: normalizeText(normalizedKickoff.openerAcceptedAt, null),
+    openerDeliveredAt: normalizeText(normalizedKickoff.openerDeliveredAt, null),
+    liveChatEstablishedAt: normalizeText(normalizedKickoff.liveChatEstablishedAt, null),
+    reason: normalizeText(normalizedKickoff.reason, null),
   };
 }