@xfxstudio/claworld 2026.5.27-testing.1 → 2026.5.28-testing.2

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

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { pathToFileURL } from 'node:url';
 import path from 'node:path';
 
 import {
@@ -99,6 +100,125 @@ function normalizePluginOptionalText(value) {
   return normalized || null;
 }
 
+function normalizeAssistantOutputTexts(value) {
+  const rawTexts = Array.isArray(value) ? value : [value];
+  const texts = [];
+  for (const rawText of rawTexts) {
+    const normalized = normalizePluginOptionalText(rawText);
+    if (normalized && !texts.includes(normalized)) texts.push(normalized);
+  }
+  return texts;
+}
+
+function pruneRecentAssistantOutputs(now = Date.now()) {
+  const pruneMap = (records) => {
+    for (const [key, record] of records.entries()) {
+      if (!record || now - Number(record.recordedAt || 0) > CLAWORLD_ASSISTANT_OUTPUT_TTL_MS) {
+        records.delete(key);
+      }
+    }
+    if (records.size <= CLAWORLD_ASSISTANT_OUTPUT_MAX_RECORDS) return;
+    const sorted = [...records.entries()].sort((a, b) =>
+      Number(a[1]?.recordedAt || 0) - Number(b[1]?.recordedAt || 0),
+    );
+    for (const [key] of sorted.slice(0, Math.max(0, records.size - CLAWORLD_ASSISTANT_OUTPUT_MAX_RECORDS))) {
+      records.delete(key);
+    }
+  };
+  pruneMap(recentAssistantOutputBySessionKey);
+  pruneMap(recentAssistantOutputBySessionId);
+}
+
+export function recordClaworldRuntimeAssistantOutput({
+  sessionKey = null,
+  sessionId = null,
+  runId = null,
+  assistantTexts = [],
+  timestamp = null,
+  recordedAt = Date.now(),
+} = {}) {
+  const texts = normalizeAssistantOutputTexts(assistantTexts);
+  if (texts.length === 0) return false;
+  const normalizedSessionKey = normalizePluginOptionalText(sessionKey);
+  const normalizedSessionId = normalizePluginOptionalText(sessionId);
+  if (!normalizedSessionKey && !normalizedSessionId) return false;
+  const record = {
+    sessionKey: normalizedSessionKey,
+    sessionId: normalizedSessionId,
+    runId: normalizePluginOptionalText(runId),
+    assistantTexts: texts,
+    timestamp: normalizePluginOptionalText(timestamp),
+    recordedAt: Number.isFinite(Number(recordedAt)) ? Number(recordedAt) : Date.now(),
+  };
+  if (normalizedSessionKey) recentAssistantOutputBySessionKey.set(normalizedSessionKey, record);
+  if (normalizedSessionId) recentAssistantOutputBySessionId.set(normalizedSessionId, record);
+  pruneRecentAssistantOutputs(record.recordedAt);
+  return true;
+}
+
+function readRecentAssistantOutputRecord({
+  sessionKeys = [],
+  sessionId = null,
+  afterMs = 0,
+} = {}) {
+  pruneRecentAssistantOutputs();
+  const candidates = [];
+  for (const sessionKey of sessionKeys) {
+    const normalizedSessionKey = normalizePluginOptionalText(sessionKey);
+    if (!normalizedSessionKey) continue;
+    const record = recentAssistantOutputBySessionKey.get(normalizedSessionKey);
+    if (record) candidates.push(record);
+  }
+  const normalizedSessionId = normalizePluginOptionalText(sessionId);
+  if (normalizedSessionId) {
+    const record = recentAssistantOutputBySessionId.get(normalizedSessionId);
+    if (record) candidates.push(record);
+  }
+  return candidates
+    .filter((record) =>
+      Number(record?.recordedAt || 0) >= afterMs
+      && normalizeAssistantOutputTexts(record?.assistantTexts).length > 0,
+    )
+    .sort((a, b) => Number(b.recordedAt || 0) - Number(a.recordedAt || 0))[0] || null;
+}
+
+async function waitForRecentAssistantOutputRecord({
+  sessionKeys = [],
+  sessionId = null,
+  afterMs = 0,
+  timeoutMs = CLAWORLD_ASSISTANT_OUTPUT_WAIT_MS,
+} = {}) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt <= timeoutMs) {
+    const record = readRecentAssistantOutputRecord({ sessionKeys, sessionId, afterMs });
+    if (record) return record;
+    await new Promise((resolve) => {
+      setTimeout(resolve, CLAWORLD_ASSISTANT_OUTPUT_POLL_MS);
+    });
+  }
+  return null;
+}
+
+async function loadOpenClawReplyRuntime() {
+  if (!openClawReplyRuntimePromise) {
+    openClawReplyRuntimePromise = import('openclaw/plugin-sdk/reply-runtime')
+      .catch(async () => {
+        const argvPath = normalizePluginOptionalText(process.argv?.[1]);
+        if (!argvPath || !argvPath.endsWith('openclaw.mjs')) return null;
+        const runtimePath = path.join(path.dirname(argvPath), 'dist', 'plugin-sdk', 'reply-runtime.js');
+        return import(pathToFileURL(runtimePath).href).catch(() => null);
+      });
+  }
+  return openClawReplyRuntimePromise;
+}
+
+async function resolveOpenClawReplyResolver(runtime = null) {
+  const directResolver = runtime?.channel?.reply?.getReplyFromConfig;
+  if (typeof directResolver === 'function') return directResolver;
+  const replyRuntime = await loadOpenClawReplyRuntime();
+  return typeof replyRuntime?.getReplyFromConfig === 'function' ? replyRuntime.getReplyFromConfig : null;
+}
+
 function requireClientMessageId(value = null) {
   const normalized = normalizePluginOptionalText(value);
   if (!normalized) {
@@ -112,6 +232,14 @@ function buildGeneratedClientMessageId() {
 }
 
 const DEFAULT_RELAY_HTTP_TIMEOUT_MS = 15_000;
+const CLAWORLD_ASSISTANT_OUTPUT_TTL_MS = 60_000;
+const CLAWORLD_ASSISTANT_OUTPUT_WAIT_MS = 750;
+const CLAWORLD_ASSISTANT_OUTPUT_POLL_MS = 25;
+const CLAWORLD_ASSISTANT_OUTPUT_MAX_RECORDS = 200;
+
+const recentAssistantOutputBySessionKey = new Map();
+const recentAssistantOutputBySessionId = new Map();
+let openClawReplyRuntimePromise = null;
 
 function buildRelayAgentSummary(item = {}) {
   const normalizedAgentId = normalizeClaworldText(item?.agentId, null);
@@ -326,6 +454,7 @@ const CLAWORLD_RELAY_OPERATIONAL_NOTICE_PATTERNS = [
   /^↪️\s*Model Fallback:/i,
   /^↪️\s*Model Fallback cleared:/i,
   /^⚠️\s*Agent failed before reply:/i,
+  /^Sent the (?:reply|opener|Claworld reply)\.?$/i,
 ];
 
 // Older/runtime-variant OpenClaw hosts may surface provider/runtime failures as
@@ -445,6 +574,87 @@ function appendRuntimeOutputPreview(previews, text) {
   previews.push(preview);
 }
 
+function buildActiveDeliveryReplyKey({ accountId = null, targetAgentId = null } = {}) {
+  return [
+    normalizePluginOptionalText(accountId) || 'default',
+    normalizePluginOptionalText(targetAgentId) || '',
+  ].join('\0');
+}
+
+function resolveClaworldTargetAliases(value) {
+  const normalized = normalizeClaworldTarget(value) || normalizePluginOptionalText(value);
+  if (!normalized) return [];
+  const aliases = new Set([normalized]);
+  const atIndex = normalized.indexOf('@');
+  if (atIndex > 0) aliases.add(normalized.slice(0, atIndex));
+  return [...aliases].filter(Boolean);
+}
+
+function createActiveDeliveryReplyRegistry() {
+  const entriesByAccountTarget = new Map();
+  const entriesByAccount = new Map();
+
+  const addAccountEntry = (accountId, entry) => {
+    const accountKey = normalizePluginOptionalText(accountId) || 'default';
+    let set = entriesByAccount.get(accountKey);
+    if (!set) {
+      set = new Set();
+      entriesByAccount.set(accountKey, set);
+    }
+    set.add(entry);
+    return accountKey;
+  };
+
+  const removeAccountEntry = (accountKey, entry) => {
+    const set = entriesByAccount.get(accountKey);
+    if (!set) return;
+    set.delete(entry);
+    if (set.size === 0) entriesByAccount.delete(accountKey);
+  };
+
+  return {
+    register(rawEntry = {}) {
+      const accountId = normalizePluginOptionalText(rawEntry.accountId) || 'default';
+      const targetAliases = resolveClaworldTargetAliases(rawEntry.targetAgentId);
+      const entry = {
+        ...rawEntry,
+        accountId,
+        targetAgentId: targetAliases[0] || normalizePluginOptionalText(rawEntry.targetAgentId),
+        registeredAt: Date.now(),
+      };
+      const accountKey = addAccountEntry(accountId, entry);
+      const exactKeys = [];
+      for (const alias of targetAliases) {
+        const key = buildActiveDeliveryReplyKey({ accountId, targetAgentId: alias });
+        entriesByAccountTarget.set(key, entry);
+        exactKeys.push(key);
+      }
+      return () => {
+        for (const key of exactKeys) {
+          if (entriesByAccountTarget.get(key) === entry) entriesByAccountTarget.delete(key);
+        }
+        removeAccountEntry(accountKey, entry);
+      };
+    },
+
+    resolve({ accountId = null, to = null } = {}) {
+      const normalizedAccountId = normalizePluginOptionalText(accountId) || 'default';
+      const targetAliases = resolveClaworldTargetAliases(to);
+      for (const targetAlias of targetAliases) {
+        const exact = entriesByAccountTarget.get(buildActiveDeliveryReplyKey({
+          accountId: normalizedAccountId,
+          targetAgentId: targetAlias,
+        }));
+        if (exact) return exact;
+      }
+      if (targetAliases.length > 0) return null;
+      const accountEntries = entriesByAccount.get(normalizedAccountId);
+      if (!accountEntries || accountEntries.size !== 1) return null;
+      return [...accountEntries][0] || null;
+    },
+  };
+}
+
 function appendPartialContinuationChunk(currentText, chunk) {
   const nextChunk = typeof chunk === 'string' ? chunk : '';
   if (!nextChunk) return currentText;
@@ -456,6 +666,14 @@ function appendPartialContinuationChunk(currentText, chunk) {
   return `${existing}${nextChunk}`;
 }
 
+function normalizeReplyResolverPayloads(result) {
+  if (!result) return [];
+  if (Array.isArray(result)) return result.filter((entry) => entry && typeof entry === 'object');
+  if (Array.isArray(result.payloads)) return result.payloads.filter((entry) => entry && typeof entry === 'object');
+  if (result && typeof result === 'object') return [result];
+  return [];
+}
+
 function buildRelayContinuationText({
   finalTexts = [],
   blockTexts = [],
@@ -2160,6 +2378,8 @@ function createDeliveryReplyDispatcher({
   relayClient,
   deliveryId,
   sessionKey,
+  localSessionKey = null,
+  sessionId = null,
   localAgentId = null,
   allowReply = true,
   logger,
@@ -2181,7 +2401,9 @@ function createDeliveryReplyDispatcher({
   let keptSilentFallbackUsed = false;
   const finalTexts = [];
   const blockTexts = [];
+  const replyResolverTexts = [];
   let partialContinuationText = '';
+  const dispatchStartedAt = Date.now();
   const runtimeOutputSummary = {
     counts: {
       final: 0,
@@ -2197,6 +2419,10 @@ function createDeliveryReplyDispatcher({
       nonRenderableFinal: 0,
       operationalNotice: 0,
       runtimeErrorFinal: 0,
+      replyResolverPayload: 0,
+      replyResolverNonRenderable: 0,
+      assistantTextFallback: 0,
+      messageToolReply: 0,
     },
     previews: {
       final: [],
@@ -2206,6 +2432,9 @@ function createDeliveryReplyDispatcher({
       reasoning: [],
       operationalNotice: [],
       runtimeErrorFinal: [],
+      replyResolver: [],
+      assistantTextFallback: [],
+      messageToolReply: [],
     },
     relayContinuationSource: 'none',
     relayContinuationPreview: null,
@@ -2246,6 +2475,60 @@ function createDeliveryReplyDispatcher({
     }
   };
 
+  const recordReplyResolverPayloads = (result) => {
+    for (const payload of normalizeReplyResolverPayloads(result)) {
+      runtimeOutputSummary.counts.replyResolverPayload += 1;
+      const classified = classifyRelayContinuationPayload(payload);
+      const text = String(payload?.text ?? payload?.body ?? '').trim();
+      if (classified.text) {
+        if (!replyResolverTexts.includes(classified.text)) {
+          replyResolverTexts.push(classified.text);
+        }
+        appendRuntimeOutputPreview(runtimeOutputSummary.previews.replyResolver, classified.text);
+      }
+      if (classified.nonRenderable) {
+        runtimeOutputSummary.counts.replyResolverNonRenderable += 1;
+      }
+      if (classified.operationalNotice) {
+        appendRuntimeOutputPreview(runtimeOutputSummary.previews.operationalNotice, classified.previewText || text);
+      }
+      if (classified.runtimeError) {
+        appendRuntimeOutputPreview(runtimeOutputSummary.previews.runtimeErrorFinal, classified.previewText || text);
+      }
+    }
+  };
+
+  const resolveAssistantTextFallback = async () => {
+    if (replyResolverTexts.length > 0) {
+      return {
+        source: 'reply_result',
+        texts: [...replyResolverTexts],
+      };
+    }
+
+    const outputRecord = await waitForRecentAssistantOutputRecord({
+      sessionKeys: [localSessionKey, sessionKey],
+      sessionId,
+      afterMs: dispatchStartedAt,
+    });
+    const assistantTexts = normalizeAssistantOutputTexts(outputRecord?.assistantTexts);
+    if (assistantTexts.length === 0) {
+      return {
+        source: 'none',
+        texts: [],
+      };
+    }
+
+    runtimeOutputSummary.counts.assistantTextFallback += assistantTexts.length;
+    for (const text of assistantTexts) {
+      appendRuntimeOutputPreview(runtimeOutputSummary.previews.assistantTextFallback, text);
+    }
+    return {
+      source: 'assistant_text',
+      texts: assistantTexts,
+    };
+  };
+
   const recordRuntimeTextEvent = (kind, text) => {
     if (!Object.prototype.hasOwnProperty.call(runtimeOutputSummary.counts, kind)) return;
     runtimeOutputSummary.counts[kind] += 1;
@@ -2301,6 +2584,21 @@ function createDeliveryReplyDispatcher({
     return true;
   };
 
+  const submitMessageToolReply = async ({ text } = {}) => {
+    const normalized = sanitizeRelayContinuationText(text);
+    if (!normalized) return false;
+    runtimeOutputSummary.counts.messageToolReply += 1;
+    appendRuntimeOutputPreview(runtimeOutputSummary.previews.messageToolReply, normalized);
+    runtimeOutputSummary.relayContinuationSource = 'message_tool';
+    runtimeOutputSummary.relayContinuationPreview = previewRuntimeOutputText(normalized);
+    if (isExactNoReplyToken(normalized)) {
+      runtimeOutputSummary.relayContinuationSource = 'message_tool_no_reply_token';
+      runtimeOutputSummary.relayContinuationPreview = 'NO_REPLY';
+      return await flushKeptSilent('no_reply_token');
+    }
+    return await flushReply(normalized);
+  };
+
   const flushKeptSilent = async (reason = null) => {
     if (replied || keptSilent || suppressed) return false;
     if (allowReply === false) {
@@ -2346,18 +2644,39 @@ function createDeliveryReplyDispatcher({
   const markDispatchIdle = async () => {
     await dispatchApi.dispatcher.waitForIdle?.();
     if (!replied && !suppressed) {
+      let assistantTextFallback = {
+        source: 'none',
+        texts: [],
+      };
+      const shouldResolveAssistantTextFallback = (
+        replyResolverTexts.length > 0
+        || runtimeOutputSummary.counts.assistantMessageStart > 0
+      );
+      if (finalTexts.length === 0 && blockTexts.length === 0 && shouldResolveAssistantTextFallback) {
+        assistantTextFallback = await resolveAssistantTextFallback();
+      }
+      const continuationFinalTexts = finalTexts.length > 0
+        ? finalTexts
+        : assistantTextFallback.texts;
       const allowPartialFallback = (
         runtimeOutputSummary.counts.final > 0
-        && finalTexts.length === 0
+        && continuationFinalTexts.length === 0
         && blockTexts.length === 0
         && runtimeOutputSummary.counts.nonRenderableFinal === 0
       );
       const safeContinuation = buildRelayContinuationText({
-        finalTexts,
+        finalTexts: continuationFinalTexts,
         blockTexts,
         partialText: partialContinuationText,
         allowPartialFallback,
       });
+      if (
+        safeContinuation.source === 'final'
+        && finalTexts.length === 0
+        && assistantTextFallback.source !== 'none'
+      ) {
+        safeContinuation.source = assistantTextFallback.source;
+      }
       runtimeOutputSummary.relayContinuationSource = safeContinuation.source;
       runtimeOutputSummary.relayContinuationPreview = safeContinuation.text
         ? previewRuntimeOutputText(safeContinuation.text)
@@ -2414,23 +2733,28 @@ function createDeliveryReplyDispatcher({
         recordRuntimeLifecycle('compactionEnd');
       },
     },
+    recordReplyResolverPayloads,
     markDispatchIdle,
     didReply: () => replied,
     didKeepSilent: () => keptSilent,
+    submitMessageToolReply,
     getRuntimeOutputSummary: () => ({
       counts: { ...runtimeOutputSummary.counts },
       previews: {
         final: [...runtimeOutputSummary.previews.final],
         block: [...runtimeOutputSummary.previews.block],
         tool: [...runtimeOutputSummary.previews.tool],
-      partial: [...runtimeOutputSummary.previews.partial],
-      reasoning: [...runtimeOutputSummary.previews.reasoning],
-      operationalNotice: [...runtimeOutputSummary.previews.operationalNotice],
-      runtimeErrorFinal: [...runtimeOutputSummary.previews.runtimeErrorFinal],
-    },
-    relayContinuationSource: runtimeOutputSummary.relayContinuationSource,
-    relayContinuationPreview: runtimeOutputSummary.relayContinuationPreview,
-    replyTransport,
+        partial: [...runtimeOutputSummary.previews.partial],
+        reasoning: [...runtimeOutputSummary.previews.reasoning],
+        operationalNotice: [...runtimeOutputSummary.previews.operationalNotice],
+        runtimeErrorFinal: [...runtimeOutputSummary.previews.runtimeErrorFinal],
+        replyResolver: [...runtimeOutputSummary.previews.replyResolver],
+        assistantTextFallback: [...runtimeOutputSummary.previews.assistantTextFallback],
+        messageToolReply: [...runtimeOutputSummary.previews.messageToolReply],
+      },
+      relayContinuationSource: runtimeOutputSummary.relayContinuationSource,
+      relayContinuationPreview: runtimeOutputSummary.relayContinuationPreview,
+      replyTransport,
       replyFallbackUsed,
       keptSilentTransport,
       keptSilentFallbackUsed,
@@ -2444,18 +2768,23 @@ async function runDeliveryReplyDispatch({
   relayClient,
   deliveryId,
   sessionKey,
+  localSessionKey,
+  sessionId,
   localAgentId,
   allowReply,
   logger,
   runtimeAccountId,
   inboundCtx,
+  activeDeliveryReplies = null,
 } = {}) {
   const {
     dispatcher,
     replyOptions,
+    recordReplyResolverPayloads,
     markDispatchIdle,
     didReply,
     didKeepSilent,
+    submitMessageToolReply,
     getRuntimeOutputSummary,
   } = createDeliveryReplyDispatcher({
     runtime,
@@ -2463,19 +2792,59 @@ async function runDeliveryReplyDispatch({
     relayClient,
     deliveryId,
     sessionKey,
+    localSessionKey,
+    sessionId,
     localAgentId,
     allowReply,
     logger,
     runtimeAccountId,
   });
 
-  const dispatchResult = await runtime.channel.reply.dispatchReplyFromConfig({
+  const baseReplyResolver = await resolveOpenClawReplyResolver(runtime);
+  const replyResolver = baseReplyResolver
+    ? async (...args) => {
+      const result = await baseReplyResolver(...args);
+      recordReplyResolverPayloads(result);
+      return result;
+    }
+    : undefined;
+
+  const dispatchParams = {
     ctx: inboundCtx,
     cfg: currentCfg,
     dispatcher,
     replyOptions,
-  });
-  await markDispatchIdle();
+  };
+  if (replyResolver) {
+    dispatchParams.replyResolver = replyResolver;
+  }
+
+  const shouldRegisterMessageToolCompat = (
+    inboundCtx?.sessionKind === 'conversation'
+    && activeDeliveryReplies
+    && typeof activeDeliveryReplies.register === 'function'
+  );
+  const unregisterMessageToolCompat = shouldRegisterMessageToolCompat
+    ? activeDeliveryReplies.register({
+      accountId: runtimeAccountId,
+      localAgentId,
+      targetAgentId: inboundCtx?.RelayFromAgentId || inboundCtx?.SenderId || inboundCtx?.OriginatingFrom || null,
+      deliveryId,
+      sessionKey,
+      localSessionKey,
+      sessionId,
+      conversationKey: inboundCtx?.RelayConversationKey || inboundCtx?.conversationKey || null,
+      submitMessageToolReply,
+    })
+    : null;
+
+  let dispatchResult;
+  try {
+    dispatchResult = await runtime.channel.reply.dispatchReplyFromConfig(dispatchParams);
+    await markDispatchIdle();
+  } finally {
+    unregisterMessageToolCompat?.();
+  }
 
   return {
     dispatchResult,
@@ -2529,6 +2898,7 @@ async function maybeBridgeRuntimeInboundEvent({
   runtime,
   cfg,
   inbound,
+  activeDeliveryReplies = null,
 }) {
   const delivery = event?.delivery && typeof event.delivery === 'object' && !Array.isArray(event.delivery)
     ? event.delivery
@@ -2661,6 +3031,7 @@ async function maybeBridgeRuntimeInboundEvent({
     CommandAuthorized: commandAuthorized,
     RelayDeliveryId: isRelayDelivery ? deliveryId : null,
     RelayFromAgentId: fromAgentId,
+    RelayConversationKey: metadata.conversationKey || null,
     UntrustedContext,
   });
 
@@ -2726,11 +3097,14 @@ async function maybeBridgeRuntimeInboundEvent({
     relayClient,
     deliveryId,
     sessionKey,
+    localSessionKey,
+    sessionId: sessionArtifacts.sessionId || null,
     localAgentId,
     allowReply,
     logger,
     runtimeAccountId,
     inboundCtx,
+    activeDeliveryReplies,
   });
 
   const shouldRetryKickoffDispatch = (
@@ -2772,11 +3146,14 @@ async function maybeBridgeRuntimeInboundEvent({
       relayClient,
       deliveryId,
       sessionKey,
+      localSessionKey,
+      sessionId: sessionArtifacts.sessionId || null,
       localAgentId,
       allowReply,
       logger,
       runtimeAccountId,
       inboundCtx,
+      activeDeliveryReplies,
     }));
   }
 
@@ -2856,6 +3233,7 @@ export function createClaworldChannelPlugin({
   const lifecycles = new Map();
   const accountRuntimeContexts = new Map();
   const accountBindingStates = new Map();
+  const activeDeliveryReplies = createActiveDeliveryReplyRegistry();
 
   function resolveAccountBindingKey(runtimeConfig = {}, fallbackAccountId = 'default') {
     return String(runtimeConfig?.accountId || fallbackAccountId || 'default');
@@ -3290,6 +3668,7 @@ export function createClaworldChannelPlugin({
               runtime: runtimeContext.runtime,
               cfg: runtimeContext.cfg,
               inbound,
+              activeDeliveryReplies,
             }).catch((error) => {
               logger.error?.(`[claworld:${runtimeAccountId}] inbound bridge exception`, {
                 error: error?.message || String(error),
@@ -3692,8 +4071,44 @@ async function generateRuntimeProfileCard(context = {}) {
       deliveryMode: 'direct',
       createReplyEnvelope: (params = {}) => outbound.createReplyEnvelope(params),
       sendText: async (ctx = {}) => {
-        if (typeof fetchImpl !== 'function') throw new Error('fetch is unavailable for claworld outbound');
         const resolvedContext = await resolveBoundRuntimeContext(ctx);
+        const activeReply = activeDeliveryReplies.resolve({
+          accountId: resolvedContext.accountId || ctx.accountId || null,
+          to: ctx.to,
+        });
+        const activeReplyText = normalizeClaworldText(ctx.text, null);
+        if (activeReply && activeReplyText) {
+          const submitted = await activeReply.submitMessageToolReply?.({
+            text: activeReplyText,
+            to: ctx.to,
+          });
+          const clientMessageId = normalizePluginOptionalText(
+            ctx.clientMessageId || ctx.metadata?.clientMessageId || null,
+          ) || buildGeneratedClientMessageId();
+          logger.info?.(`[claworld:${resolvedContext.accountId || ctx.accountId || 'default'}] routed message tool send through active delivery reply`, {
+            deliveryId: activeReply.deliveryId || null,
+            sessionKey: activeReply.sessionKey || null,
+            localSessionKey: activeReply.localSessionKey || null,
+            targetAgentId: activeReply.targetAgentId || normalizeClaworldTarget(ctx.to) || null,
+            submitted: submitted === true,
+          });
+          return {
+            channel: 'claworld',
+            messageId: activeReply.deliveryId || `delivery_${Date.now()}`,
+            chatId: activeReply.targetAgentId || normalizeClaworldTarget(ctx.to) || ctx.to || null,
+            timestamp: Date.now(),
+            meta: {
+              clientMessageId,
+              sessionKey: activeReply.sessionKey || null,
+              turnId: activeReply.deliveryId || null,
+              conversationKey: activeReply.conversationKey || null,
+              targetAgentId: activeReply.targetAgentId || normalizeClaworldTarget(ctx.to) || null,
+              deliveryId: activeReply.deliveryId || null,
+              routedVia: 'delivery_reply',
+            },
+          };
+        }
+        if (typeof fetchImpl !== 'function') throw new Error('fetch is unavailable for claworld outbound');
         return deliverRelayMessage({
           runtimeConfig: resolvedContext.runtimeConfig,
           to: ctx.to,