@xfxstudio/claworld 2026.4.14-testing.2 → 2026.4.16-testing.1

package/src/openclaw/plugin/runtime-backup.js

@@ -1,105 +0,0 @@
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-
-import {
-  DEFAULT_CLAWORLD_ACCOUNT_ID,
-  findClaworldManagedRuntimeBackup,
-  setClaworldManagedRuntimeBackupState,
-  stripClaworldManagedRuntimeConfig,
-} from './managed-config.js';
-
-function normalizeText(value, fallback = null) {
-  if (value == null) return fallback;
-  const normalized = String(value).trim();
-  return normalized || fallback;
-}
-
-export function resolveDefaultOpenClawConfigPath() {
-  return path.resolve(normalizeText(
-    process.env.OPENCLAW_CONFIG_PATH,
-    path.join(os.homedir(), '.openclaw', 'openclaw.json'),
-  ));
-}
-
-export function resolveClaworldInstallerStatePath(configPath = resolveDefaultOpenClawConfigPath()) {
-  const resolvedConfigPath = path.resolve(String(configPath));
-  return path.join(path.dirname(resolvedConfigPath), '.claworld-installer-state.json');
-}
-
-async function loadInstallerStateFromDisk(installerStatePath) {
-  try {
-    const raw = await fs.readFile(installerStatePath, 'utf8');
-    const parsed = JSON.parse(raw);
-    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
-  } catch (error) {
-    if (error?.code === 'ENOENT') return {};
-    throw error;
-  }
-}
-
-async function writeInstallerStateToDisk(installerStatePath, installerState) {
-  const nextState = installerState && typeof installerState === 'object' && !Array.isArray(installerState)
-    ? installerState
-    : {};
-  if (Object.keys(nextState).length === 0) {
-    await fs.rm(installerStatePath, { force: true });
-    return;
-  }
-  await fs.mkdir(path.dirname(installerStatePath), { recursive: true });
-  await fs.writeFile(installerStatePath, `${JSON.stringify(nextState, null, 2)}\n`, 'utf8');
-}
-
-export async function loadClaworldRuntimeBackup({
-  accountId = DEFAULT_CLAWORLD_ACCOUNT_ID,
-  configPath = resolveDefaultOpenClawConfigPath(),
-} = {}) {
-  const installerStatePath = resolveClaworldInstallerStatePath(configPath);
-  const installerState = await loadInstallerStateFromDisk(installerStatePath);
-  return {
-    installerStatePath,
-    installerState,
-    backup: findClaworldManagedRuntimeBackup(installerState, accountId),
-  };
-}
-
-export async function persistClaworldRuntimeBackup({
-  runtime = null,
-  accountId = DEFAULT_CLAWORLD_ACCOUNT_ID,
-  configPath = resolveDefaultOpenClawConfigPath(),
-} = {}) {
-  if (!runtime?.config?.loadConfig) {
-    return { skipped: true, reason: 'missing_runtime_config_loader' };
-  }
-
-  const currentConfig = await runtime.config.loadConfig();
-  const { backup } = stripClaworldManagedRuntimeConfig(currentConfig, {
-    accountId,
-    preserveBackup: true,
-  });
-
-  if (!backup?.appToken) {
-    return { skipped: true, reason: 'missing_app_token', backup: null };
-  }
-
-  const installerStatePath = resolveClaworldInstallerStatePath(configPath);
-  const installerState = await loadInstallerStateFromDisk(installerStatePath);
-  const previousBackup = findClaworldManagedRuntimeBackup(installerState, accountId);
-  if (JSON.stringify(previousBackup || null) === JSON.stringify(backup)) {
-    return {
-      skipped: true,
-      reason: 'already_persisted',
-      installerStatePath,
-      backup,
-    };
-  }
-
-  setClaworldManagedRuntimeBackupState(installerState, accountId, backup);
-  await writeInstallerStateToDisk(installerStatePath, installerState);
-  return {
-    skipped: false,
-    ok: true,
-    installerStatePath,
-    backup,
-  };
-}

package/src/openclaw/plugin/runtime.js

@@ -1,12 +0,0 @@
-let currentRuntime = null;
-
-export function setClaworldRuntime(runtime) {
-  currentRuntime = runtime || null;
-}
-
-export function getClaworldRuntime() {
-  if (!currentRuntime) {
-    throw new Error('Claworld runtime not initialized');
-  }
-  return currentRuntime;
-}

package/src/openclaw/plugin-version.js

@@ -1,67 +0,0 @@
-import { readFileSync } from 'node:fs';
-import repoPackageJson from '../../package.json' with { type: 'json' };
-
-export const CLAWORLD_PLUGIN_PACKAGE_NAME = '@xfxstudio/claworld';
-export const CLAWORLD_PLUGIN_VERSION_HEADER = 'x-claworld-plugin-version';
-
-function normalizeText(value, fallback = null) {
-  if (value == null) return fallback;
-  const normalized = String(value).trim();
-  return normalized || fallback;
-}
-
-function normalizeHeaderValue(value) {
-  if (Array.isArray(value)) {
-    return normalizeHeaderValue(value[0]);
-  }
-  const normalized = normalizeText(value, null);
-  if (!normalized) return null;
-  return normalized.split(',')[0]?.trim() || null;
-}
-
-export function normalizeClaworldPluginVersion(value, fallback = null) {
-  const normalized = normalizeText(value, null);
-  if (!normalized) return fallback;
-  const withoutPrefix = normalized.replace(/^v/i, '');
-  if (!/^\d+(?:\.\d+)*(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(withoutPrefix)) {
-    return fallback;
-  }
-  return withoutPrefix;
-}
-
-function resolveCurrentPluginVersion() {
-  const repoVersion = normalizeClaworldPluginVersion(repoPackageJson?.version, null);
-  if (repoPackageJson?.name === CLAWORLD_PLUGIN_PACKAGE_NAME && repoVersion) {
-    return repoVersion;
-  }
-
-  try {
-    const publishSurfaceSource = readFileSync(
-      new URL('../../packages/openclaw-plugin/package.json', import.meta.url),
-      'utf8',
-    );
-    const publishSurfacePackageJson = JSON.parse(publishSurfaceSource);
-    const publishSurfaceVersion = normalizeClaworldPluginVersion(publishSurfacePackageJson?.version, null);
-    if (publishSurfacePackageJson?.name === CLAWORLD_PLUGIN_PACKAGE_NAME && publishSurfaceVersion) {
-      return publishSurfaceVersion;
-    }
-  } catch {}
-
-  return repoVersion || '0.0.0';
-}
-
-export const CLAWORLD_PLUGIN_CURRENT_VERSION = resolveCurrentPluginVersion();
-
-export function readClaworldPluginVersionFromHeaders(headers = {}) {
-  const rawVersion = normalizeHeaderValue(headers?.[CLAWORLD_PLUGIN_VERSION_HEADER]);
-  return {
-    rawVersion,
-    reportedVersion: normalizeClaworldPluginVersion(rawVersion, rawVersion),
-    normalizedVersion: normalizeClaworldPluginVersion(rawVersion, null),
-    source: rawVersion ? CLAWORLD_PLUGIN_VERSION_HEADER : null,
-  };
-}
-
-export function buildClaworldRelayClientVersion(version = CLAWORLD_PLUGIN_CURRENT_VERSION) {
-  return `claworld-plugin/${normalizeClaworldPluginVersion(version, CLAWORLD_PLUGIN_CURRENT_VERSION)}`;
-}

package/src/openclaw/protocol/relay-event-protocol.js

@@ -1,43 +0,0 @@
-export const CLAWORLD_PLUGIN_BRIDGE_PROTOCOL = 'claworld.delivery_reply.v1';
-
-const DELIVERY_EVENT_TYPE = 'delivery';
-
-function normalizeText(value, fallback = null) {
-  if (value == null) return fallback;
-  const normalized = String(value).trim();
-  return normalized || fallback;
-}
-
-function normalizePayload(payload = null) {
-  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return {};
-  return { ...payload };
-}
-
-export function createRelayEventProtocol() {
-  return {
-    version: CLAWORLD_PLUGIN_BRIDGE_PROTOCOL,
-    eventTypes: [DELIVERY_EVENT_TYPE],
-    requiredEnvelopeFields: ['eventType', 'deliveryId', 'sessionKey', 'payload'],
-    describeEvent(event = {}) {
-      const payload = normalizePayload(event.payload);
-      const missing = [];
-      if (normalizeText(event.eventType, null) !== DELIVERY_EVENT_TYPE) {
-        missing.push('eventType');
-      }
-      if (!normalizeText(event.deliveryId, null)) {
-        missing.push('deliveryId');
-      }
-      if (!normalizeText(event.sessionKey, null)) {
-        missing.push('sessionKey');
-      }
-      if (!normalizeText(payload.text, null)) {
-        missing.push('payload.text');
-      }
-      return {
-        ok: missing.length === 0,
-        missing,
-        role: 'delivery',
-      };
-    },
-  };
-}

package/src/openclaw/runtime/backend-error-context.js

@@ -1,91 +0,0 @@
-function normalizeText(value, fallback = null) {
-  if (value == null) return fallback;
-  const normalized = String(value).trim();
-  return normalized || fallback;
-}
-
-function normalizeFieldError(fieldError = {}) {
-  const fieldId = normalizeText(fieldError.fieldId, null);
-  const message = normalizeText(fieldError.message, null);
-  const code = normalizeText(fieldError.code, null);
-  if (!fieldId && !message && !code) return null;
-  return {
-    ...(fieldId ? { fieldId } : {}),
-    ...(message ? { message } : {}),
-    ...(code ? { code } : {}),
-  };
-}
-
-function normalizeMissingField(field = {}) {
-  const fieldId = normalizeText(field.fieldId, null);
-  const label = normalizeText(field.label, null);
-  const description = normalizeText(field.description, null);
-  const message = normalizeText(field.message, null);
-  const code = normalizeText(field.code, null);
-  if (!fieldId && !label && !description && !message && !code) return null;
-  return {
-    ...(fieldId ? { fieldId } : {}),
-    ...(label ? { label } : {}),
-    ...(description ? { description } : {}),
-    ...(message ? { message } : {}),
-    ...(code ? { code } : {}),
-  };
-}
-
-function normalizePublicIdentity(publicIdentity = {}) {
-  const status = normalizeText(publicIdentity.status, null);
-  const displayName = normalizeText(publicIdentity.displayName, null);
-  const code = normalizeText(publicIdentity.code, null);
-  const displayIdentity = normalizeText(publicIdentity.displayIdentity, null);
-  const confirmedAt = normalizeText(publicIdentity.confirmedAt, null);
-  const updatedAt = normalizeText(publicIdentity.updatedAt, null);
-  if (!status && !displayName && !code && !displayIdentity && !confirmedAt && !updatedAt) return null;
-  return {
-    ...(status ? { status } : {}),
-    ...(displayName ? { displayName } : {}),
-    ...(code ? { code } : {}),
-    ...(displayIdentity ? { displayIdentity } : {}),
-    ...(confirmedAt ? { confirmedAt } : {}),
-    ...(updatedAt ? { updatedAt } : {}),
-  };
-}
-
-export function normalizeBackendFieldError(fieldError = {}) {
-  return normalizeFieldError(fieldError);
-}
-
-export function normalizeBackendMissingField(field = {}) {
-  return normalizeMissingField(field);
-}
-
-export function normalizeBackendPublicIdentity(publicIdentity = {}) {
-  return normalizePublicIdentity(publicIdentity);
-}
-
-export function extractBackendErrorContext(payload = {}) {
-  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return {};
-
-  const backendCode = normalizeText(payload.error, null);
-  const backendMessage = normalizeText(payload.message, null);
-  const requiredAction = normalizeText(payload.requiredAction, null);
-  const nextAction = normalizeText(payload.nextAction, null);
-  const nextTool = normalizeText(payload.nextTool, null);
-  const fieldErrors = Array.isArray(payload.fieldErrors)
-    ? payload.fieldErrors.map((fieldError) => normalizeFieldError(fieldError)).filter(Boolean)
-    : [];
-  const missingFields = Array.isArray(payload.missingFields)
-    ? payload.missingFields.map((field) => normalizeMissingField(field)).filter(Boolean)
-    : [];
-  const publicIdentity = normalizePublicIdentity(payload.publicIdentity);
-
-  return {
-    ...(backendCode ? { backendCode } : {}),
-    ...(backendMessage ? { backendMessage } : {}),
-    ...(requiredAction ? { requiredAction } : {}),
-    ...(nextAction ? { nextAction } : {}),
-    ...(nextTool ? { nextTool } : {}),
-    ...(fieldErrors.length > 0 ? { fieldErrors } : {}),
-    ...(missingFields.length > 0 ? { missingFields } : {}),
-    ...(publicIdentity ? { publicIdentity } : {}),
-  };
-}

package/src/openclaw/runtime/canonical-result-builder.js

@@ -1,126 +0,0 @@
-function normalizeSignal(signal = {}, index = 0, source = 'unknown') {
-  const score = Number.isFinite(Number(signal.score)) ? Number(signal.score) : 0;
-  const risk = Number.isFinite(Number(signal.risk)) ? Number(signal.risk) : 0;
-  return {
-    id: signal.id || `${source}_${index + 1}`,
-    type: signal.type || 'note',
-    source,
-    score,
-    risk,
-    summary: signal.summary || signal.text || signal.type || `${source} signal ${index + 1}`,
-    weight: Number.isFinite(Number(signal.weight)) ? Number(signal.weight) : 1,
-    metadata: signal.metadata || {},
-  };
-}
-
-function computeWeightedAverage(signals) {
-  if (signals.length === 0) return null;
-  const totalWeight = signals.reduce((sum, signal) => sum + signal.weight, 0);
-  if (totalWeight <= 0) return null;
-  const totalScore = signals.reduce((sum, signal) => sum + signal.score * signal.weight, 0);
-  return Number((totalScore / totalWeight).toFixed(3));
-}
-
-function collectRisks(signals) {
-  return signals
-    .filter((signal) => signal.risk > 0)
-    .sort((a, b) => b.risk - a.risk)
-    .map((signal) => signal.summary);
-}
-
-function buildSummary({ matchScore, riskCount, intentCount, conversationCount, agentCount }) {
-  const scoreText = matchScore == null ? 'insufficient evidence' : `match score ${matchScore}`;
-  return `Canonical result built from ${intentCount} intent, ${conversationCount} conversation, ${agentCount} agent signals; ${scoreText}; ${riskCount} risk signal(s).`;
-}
-
-function pickRecommendation({ matchScore, normalizedSignals, risks }) {
-  const readySignals = normalizedSignals.filter(
-    (signal) => signal.type === 'next_step_ready'
-      || signal.type === 'human_handoff_ready'
-      || signal.type === 'conversation_complete',
-  ).length;
-  const hardBlock = normalizedSignals.some(
-    (signal) => signal.type === 'block' || signal.metadata?.hardBlock === true || signal.risk >= 0.85,
-  );
-  if (hardBlock) return 'pass';
-  if (readySignals >= 2 && (matchScore == null || matchScore >= 0.45) && risks.length <= 1) {
-    return 'continue';
-  }
-  if (matchScore != null && matchScore >= 0.65 && risks.length === 0) {
-    return 'continue';
-  }
-  if (matchScore != null && matchScore < 0.25) {
-    return 'pass';
-  }
-  return 'review';
-}
-
-export function createCanonicalResultBuilder() {
-  return {
-    schema: {
-      match_score: 'number',
-      summary: 'string',
-      risks: 'string[]',
-      recommendation: 'continue|pass|review',
-      evidence: 'ConversationMessage[]',
-    },
-    build({
-      conversationId = null,
-      intentSignals = [],
-      conversationSignals = [],
-      agentSignals = [],
-    } = {}) {
-      const resolvedConversationId = conversationId || null;
-      const normalizedIntentSignals = intentSignals.map((signal, index) =>
-        normalizeSignal(signal, index, 'intent'),
-      );
-      const normalizedConversationSignals = conversationSignals.map((signal, index) =>
-        normalizeSignal(signal, index, 'conversation'),
-      );
-      const normalizedAgentSignals = agentSignals.map((signal, index) =>
-        normalizeSignal(signal, index, 'agent'),
-      );
-      const normalizedSignals = [
-        ...normalizedIntentSignals,
-        ...normalizedConversationSignals,
-        ...normalizedAgentSignals,
-      ];
-
-      const matchScore = computeWeightedAverage(normalizedSignals);
-      const risks = collectRisks(normalizedSignals);
-      const recommendation = pickRecommendation({ matchScore, normalizedSignals, risks });
-      const evidence = normalizedSignals
-        .sort((a, b) => Math.abs(b.score) + b.risk - (Math.abs(a.score) + a.risk))
-        .slice(0, 5)
-        .map((signal) => ({
-          id: signal.id,
-          type: signal.type,
-          source: signal.source,
-          summary: signal.summary,
-          score: signal.score,
-          risk: signal.risk,
-        }));
-
-      return {
-        conversationId: resolvedConversationId,
-        match_score: matchScore,
-        summary: buildSummary({
-          matchScore,
-          riskCount: risks.length,
-          intentCount: normalizedIntentSignals.length,
-          conversationCount: normalizedConversationSignals.length,
-          agentCount: normalizedAgentSignals.length,
-        }),
-        risks,
-        recommendation,
-        evidence,
-        inputs: {
-          intentSignalsCount: normalizedIntentSignals.length,
-          conversationSignalsCount: normalizedConversationSignals.length,
-          agentSignalsCount: normalizedAgentSignals.length,
-        },
-        status: 'built',
-      };
-    },
-  };
-}

package/src/openclaw/runtime/demo-session-bootstrap.js

@@ -1,32 +0,0 @@
-export function createDemoSessionBootstrap() {
-  return {
-    defaults: {
-      users: ['demo-a', 'demo-b'],
-      world: 'dating-demo-world',
-      allowDemoToken: true,
-    },
-    createLaunchPlan({
-      sessionGoal = 'run one stable A2A demo loop',
-      users,
-      world,
-      openingMessage = 'You are entering demo mode. Try to complete one stable match loop.',
-    } = {}) {
-      const resolvedUsers = Array.isArray(users) && users.length > 0 ? users : this.defaults.users;
-      const resolvedWorld = world || this.defaults.world;
-      return {
-        sessionGoal,
-        world: resolvedWorld,
-        users: resolvedUsers,
-        openingMessage,
-        steps: [
-          'load demo users',
-          'load demo world',
-          'create manual session',
-          'inject opening system message',
-          'wait for conversation closure or manual stop',
-        ],
-        status: 'planned',
-      };
-    },
-  };
-}

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

@@ -1,145 +0,0 @@
-import { resolveClaworldRuntimeConfig } from '../plugin/config-schema.js';
-import { buildRuntimeAuthHeaders } from '../plugin/account-identity.js';
-import { createRuntimeBoundaryError } from '../../lib/runtime-errors.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 normalizeObject(value) {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
-  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,
-  runtimeConfig = null,
-  agentId = null,
-  category = null,
-  title = null,
-  goal = null,
-  actualBehavior = null,
-  expectedBehavior = null,
-  impact = null,
-  details = null,
-  reproductionSteps = [],
-  context = {},
-  fetchImpl,
-  logger = console,
-  toolCallId = null,
-  pluginVersion = null,
-  toolContractVersion = null,
-} = {}) {
-  if (typeof fetchImpl !== 'function') {
-    throw new Error('fetch is unavailable for claworld feedback helper');
-  }
-
-  const resolvedAgentId = normalizeText(agentId, null);
-  if (!resolvedAgentId) {
-    throw new Error('claworld feedback helper requires agentId');
-  }
-
-  const normalizedContext = normalizeObject(context);
-  const resolvedRuntimeConfig = runtimeConfig || resolveClaworldRuntimeConfig(cfg, accountId);
-  const baseUrl = normalizeRelayHttpBaseUrl(resolvedRuntimeConfig.serverUrl);
-  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/feedback`, {
-    method: 'POST',
-    headers: buildRuntimeAuthHeaders(resolvedRuntimeConfig, {
-      accept: 'application/json',
-      'content-type': 'application/json',
-      ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
-    }),
-    body: JSON.stringify({
-      agentId: resolvedAgentId,
-      accountId: normalizeText(resolvedRuntimeConfig.accountId, normalizeText(accountId, null)),
-      category,
-      title,
-      goal,
-      actualBehavior,
-      expectedBehavior,
-      impact,
-      details,
-      reproductionSteps,
-      context: {
-        worldId: normalizeText(normalizedContext.worldId, null),
-        conversationKey: normalizeText(normalizedContext.conversationKey, null),
-        turnId: normalizeText(normalizedContext.turnId, null),
-        deliveryId: normalizeText(normalizedContext.deliveryId, null),
-        targetAgentId: normalizeText(normalizedContext.targetAgentId, null),
-        tags: normalizeStringList(normalizedContext.tags),
-        metadata: normalizeObject(normalizedContext.metadata),
-      },
-      source: 'openclaw_tool',
-      runtimeContext: {
-        channelId: 'claworld',
-        toolName: 'claworld_submit_feedback',
-        toolCallId: normalizeText(toolCallId, null),
-        pluginVersion: normalizeText(pluginVersion, null),
-        toolContractVersion: normalizeText(toolContractVersion, null),
-        accountId: normalizeText(resolvedRuntimeConfig.accountId, normalizeText(accountId, null)),
-        serverUrl: baseUrl,
-        relayAgentId: resolvedAgentId,
-        defaultTargetAgentId: normalizeText(resolvedRuntimeConfig.relay?.defaultTargetAgentId, null),
-      },
-    }),
-  });
-
-  if (!result.ok) {
-    logger.error?.('[claworld:feedback] feedback submit failed', {
-      status: result.status,
-      accountId: resolvedRuntimeConfig.accountId || accountId || null,
-      body: result.body,
-    });
-    throw new Error(`claworld feedback submit failed: ${result.status}`);
-  }
-
-  return result.body;
-}

package/src/openclaw/runtime/inbound-session-router.js

@@ -1,44 +0,0 @@
-import { OPENCLAW_RUNTIME_PATH, createRuntimePathTrace } from './runtime-path.js';
-
-function normalizeText(value, fallback = null) {
-  if (value == null) return fallback;
-  const normalized = String(value).trim();
-  return normalized || fallback;
-}
-
-function normalizePayload(payload = null) {
-  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return {};
-  return { ...payload };
-}
-
-export function createInboundSessionRouter() {
-  return {
-    runtimePath: OPENCLAW_RUNTIME_PATH,
-    routeInboundEvent(event = {}, options = {}) {
-      const eventType = normalizeText(event.eventType || event.type, null);
-      const deliveryId = normalizeText(event.deliveryId || event.event_id || event.eventId, null);
-      const sessionKey = normalizeText(event.sessionKey, null);
-      const payload = normalizePayload(event.payload);
-      return {
-        action: 'route_delivery',
-        target: normalizeText(options.sessionTarget, 'mainagent'),
-        fallbackTarget: normalizeText(options.fallbackTarget, 'mainagent'),
-        eventType,
-        deliveryId,
-        sessionKey,
-        payload,
-        metadata: event.metadata && typeof event.metadata === 'object' && !Array.isArray(event.metadata)
-          ? { ...event.metadata }
-          : {},
-        trace: createRuntimePathTrace({
-          sessionKey,
-          eventId: deliveryId,
-          direction: 'inbound',
-        }),
-        status: eventType === 'delivery' && deliveryId && sessionKey && normalizeText(payload.text, null)
-          ? 'resolved'
-          : 'invalid',
-      };
-    },
-  };
-}