Auto-merge upstream openclaw/openclaw

Author: friuns2

CHANGELOG.md

@@ -10,6 +10,10 @@ Docs: https://docs.openclaw.ai
 
 - Agents/context engines: run opt-in turn maintenance as idle-aware background work so the next foreground turn no longer waits on proactive maintenance. (#65233) thanks @100yenadmin
 
+- Plugins/status: report the registered context-engine IDs in `plugins inspect` instead of the owning plugin ID, so non-matching engine IDs and multi-engine plugins are classified correctly. (#58766) thanks @zhuisDEV
+- Context engines: reject resolved plugin engines whose reported `info.id` does not match their registered slot id, so malformed engines fail fast before id-based runtime branches can misbehave. (#63222) Thanks @fuller-stack-dev.
+- WhatsApp: patch installed Baileys media encryption writes during OpenClaw postinstall so the default npm/install.sh delivery path waits for encrypted media files to finish flushing before readback, avoiding transient `ENOENT` crashes on image sends. (#65896) Thanks @frankekn.
+- Gateway/update: unify service entrypoint resolution around the canonical bundled gateway entrypoint so update, reinstall, and doctor repair stop drifting between stale `dist/entry.js` and current `dist/index.js` paths. (#65984) Thanks @mbelinky.
 ## 2026.4.12
 
 ### Changes
@@ -119,6 +123,7 @@ Docs: https://docs.openclaw.ai
 - Telegram/sessions: keep topic-scoped session initialization on the canonical topic transcript path when inbound turns omit `MessageThreadId`, so one topic session no longer alternates between bare and topic-qualified transcript files. (#64869) Thanks @jalehman.
 - Agents/failover: scope assistant-side fallback classification and surfaced provider errors to the current attempt instead of stale session history, so cross-provider fallback runs stop inheriting the previous provider's failure. (#62907) Thanks @stainlu.
 - MiniMax/OAuth: write `api: "anthropic-messages"` and `authHeader: true` into the `minimax-portal` config patch during `openclaw configure`, so re-authenticated portal setups keep Bearer auth routing working. (#64964) Thanks @ryanlee666.
+- Agents/tools: stop repeated unavailable-tool retries from escaping loop detection when the model changes arguments, and rewrite over-threshold unknown tool calls into plain assistant text before dispatch. (#65922) Thanks @dutifulbob.
 
 ## 2026.4.10
 
@@ -311,6 +316,7 @@ Docs: https://docs.openclaw.ai
 - Control UI/models: preserve provider-qualified refs for OpenRouter catalog models whose ids already contain slashes so picker selections submit allowlist-compatible model refs instead of dropping the `openrouter/` prefix. (#63416) Thanks @sallyom.
 - Plugin SDK/command auth: split command status builders onto the lightweight `openclaw/plugin-sdk/command-status` subpath while preserving deprecated `command-auth` compatibility exports, so auth-only plugin imports no longer pull status/context warmup into CLI onboarding paths. (#63174) Thanks @hxy91819.
 - Wizard/plugin config: coerce integer-typed plugin config fields from interactive text input so integer schema values persist as numbers instead of failing validation. (#63346) Thanks @jalehman.
+- npm packaging: derive required root runtime mirrors from bundled plugin manifests and built root chunks, then install packed release tarballs without the repo `node_modules` so release checks catch missing plugin deps before publish.
 
 ## 2026.4.8
 
@@ -765,6 +771,24 @@ Docs: https://docs.openclaw.ai
 - Agents/MCP: dispose bundled MCP runtimes after one-shot `openclaw agent --local` runs finish, while preserving bundled MCP state across in-run retries so local JSON runs exit cleanly without restarting stateful MCP tools mid-run.
 - Gateway/OpenAI HTTP: restore default operator scopes for bearer-authenticated requests that omit `x-openclaw-scopes`, so headless `/v1/chat/completions` and session-history callers work again after the recent method-scope hardening. (#57596) Thanks @openperf.
 - Gateway/attachments: offload large inbound images without leaking `media://` markers into text-only runs, preserve mixed attachment order for model input/transcripts, and fail closed when model image capability cannot be resolved. (#55513) Thanks @Syysean.
+- Agents/subagents: fix interim subagent runtime display so `/subagents list` and `/subagents info` stop inflating short runtimes and show second-level durations correctly. (#57739) Thanks @samzong.
+- Diffs/config: preserve schema-shaped plugin config parsing from `diffsPluginConfigSchema.safeParse()`, so direct callers keep `defaults` and `security` sections instead of receiving flattened tool defaults. (#57904) Thanks @gumadeiras.
+- Diffs: fall back to plain text when `lang` hints are invalid during diff render and viewer hydration, so bad or stale language values no longer break the diff viewer. (#57902) Thanks @gumadeiras.
+- Doctor/plugins: skip false Matrix legacy-helper warnings when no migration plans exist, and keep bundled `enabledByDefault` plugins in the gateway startup set. (#57931) Thanks @dinakars777.
+- Matrix/CLI send: start one-off Matrix send clients before outbound delivery so `openclaw message send --channel matrix` restores E2EE in encrypted rooms instead of sending plain events. (#57936) Thanks @gumadeiras.
+- xAI/Responses: normalize image-bearing tool results for xAI responses payloads, including OpenResponses-style `input_image.source` parts, so image tool replays no longer 422 on the follow-up turn. (#58017) Thanks @neeravmakwana.
+- Cron/isolated sessions: carry the full live-session provider, model, and auth-profile selection across retry restarts so cron jobs with model overrides no longer fail or loop on mid-run model-switch requests. (#57972) Thanks @issaba1.
+- Matrix/direct rooms: stop trusting remote `is_direct`, honor explicit local `is_direct: false` for discovered DM candidates, and avoid extra member-state lookups for shared rooms so DM routing and repair stay aligned. (#57124) Thanks @w-sss.
+- Agents/sandbox: make remote FS bridge reads pin the parent path and open the file atomically in the helper so read access cannot race path resolution. Thanks @AntAISecurityLab and @vincentkoc.
+- Tools/web_fetch: add an explicit trusted env-proxy path for proxy-only installs while keeping strict SSRF fetches on the pinned direct path, so trusted proxy routing does not weaken strict destination binding. (#50650) Thanks @kkav004.
+- Exec/env: block Python package index override variables from request-scoped host exec environment sanitization so package fetches cannot be redirected through a caller-supplied index. Thanks @nexrin and @vincentkoc.
+- Telegram/audio: transcode Telegram voice-note `.ogg` attachments before the local `whisper-cli` auto fallback runs, and keep mention-preflight transcription enabled in auto mode when `tools.media.audio` is unset.
+- Matrix/direct rooms: recover fresh auto-joined 1:1 DMs without eagerly persisting invite-only `m.direct` mappings, while keeping named, aliased, and explicitly configured rooms on the room path. (#58024) Thanks @gumadeiras.
+- TTS: Restore 3.28 schema compatibility and fallback observability. (#57953) Thanks @joshavant.
+- Telegram/forum topics: restore reply routing to the active topic and keep ACP `sessions_spawn(..., thread=true, mode="session")` bound to that same topic instead of falling back to root chat or losing follow-up routing. (#56060) Thanks @one27001.
+- Config/SecretRef + Control UI: harden SecretRef redaction round-trip restore, block unsafe raw fallback (force Form mode when raw is unavailable), and preflight submitted-config SecretRefs before config write RPC persistence. (#58044) Thanks @joshavant.
+- Config/Telegram: migrate removed `channels.telegram.groupMentionsOnly` into `channels.telegram.groups["*"].requireMention` on load so legacy configs no longer crash at startup. (#55336) thanks @jameslcowan.
+- Gateway/SecretRef: resolve restart token drift checks with merged service/runtime env sources and hard-fail unsupported mutable SecretRef plus OAuth-profile combinations so restart warnings and policy enforcement match runtime behavior. (#58141) Thanks @joshavant.
 - Telegram/outbound chunking: use static markdown chunking when Telegram runtime state is unavailable so long outbound Telegram messages still split correctly after cold starts. (#57816) Thanks @ForestDengHK.
 - Update/Corepack: disable interactive Corepack download prompts during update preflight install unless `COREPACK_ENABLE_DOWNLOAD_PROMPT` is already explicitly set, so `openclaw update` can fetch the repo-pinned pnpm version non-interactively. (#61456) Thanks @p6l-richard.
 

extensions/discord/src/monitor/inbound-dedupe.ts

@@ -0,0 +1,73 @@
+import { createClaimableDedupe, type ClaimableDedupe } from "openclaw/plugin-sdk/persistent-dedupe";
+import type { DiscordMessageEvent } from "./listeners.js";
+import { resolveDiscordMessageChannelId } from "./message-utils.js";
+
+const RECENT_DISCORD_MESSAGE_TTL_MS = 5 * 60_000;
+const RECENT_DISCORD_MESSAGE_MAX = 5000;
+
+export function createDiscordInboundReplayGuard(): ClaimableDedupe {
+  return createClaimableDedupe({
+    ttlMs: RECENT_DISCORD_MESSAGE_TTL_MS,
+    memoryMaxSize: RECENT_DISCORD_MESSAGE_MAX,
+  });
+}
+
+export class DiscordRetryableInboundError extends Error {
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "DiscordRetryableInboundError";
+  }
+}
+
+export function buildDiscordInboundReplayKey(params: {
+  accountId: string;
+  data: DiscordMessageEvent;
+}): string | null {
+  const messageId = params.data.message?.id?.trim();
+  if (!messageId) {
+    return null;
+  }
+  const channelId = resolveDiscordMessageChannelId({
+    message: params.data.message,
+    eventChannelId: params.data.channel_id,
+  });
+  if (!channelId) {
+    return null;
+  }
+  return `${params.accountId}:${channelId}:${messageId}`;
+}
+
+export async function claimDiscordInboundReplay(params: {
+  replayKey?: string | null;
+  replayGuard: ClaimableDedupe;
+}): Promise<boolean> {
+  const replayKey = params.replayKey?.trim();
+  if (!replayKey) {
+    return true;
+  }
+  const claim = await params.replayGuard.claim(replayKey);
+  return claim.kind === "claimed";
+}
+
+export async function commitDiscordInboundReplay(params: {
+  replayKeys?: readonly (string | null | undefined)[];
+  replayGuard: ClaimableDedupe;
+}): Promise<void> {
+  const replayKeys = normalizeDiscordInboundReplayKeys(params.replayKeys);
+  await Promise.all(replayKeys.map((replayKey) => params.replayGuard.commit(replayKey)));
+}
+
+export function releaseDiscordInboundReplay(params: {
+  replayKeys?: readonly (string | null | undefined)[];
+  replayGuard: ClaimableDedupe;
+  error?: unknown;
+}): void {
+  const replayKeys = normalizeDiscordInboundReplayKeys(params.replayKeys);
+  replayKeys.forEach((replayKey) => params.replayGuard.release(replayKey, { error: params.error }));
+}
+
+function normalizeDiscordInboundReplayKeys(
+  replayKeys?: readonly (string | null | undefined)[],
+): string[] {
+  return [...new Set((replayKeys ?? []).map((replayKey) => replayKey?.trim()).filter(Boolean))];
+}

extensions/discord/src/monitor/inbound-job.test.ts

@@ -92,7 +92,7 @@ describe("buildDiscordInboundJob", () => {
 
   it("re-materializes the process context with an overridden abort signal", async () => {
     const ctx = await createBaseDiscordMessageContext();
-    const job = buildDiscordInboundJob(ctx);
+    const job = buildDiscordInboundJob(ctx, { replayKeys: ["default:ch-1:m-1"] });
     const overrideAbortController = new AbortController();
 
     const rematerialized = materializeDiscordInboundJob(job, overrideAbortController.signal);
@@ -103,6 +103,7 @@ describe("buildDiscordInboundJob", () => {
     expect(rematerialized.abortSignal).toBe(overrideAbortController.signal);
     expect(rematerialized.message).toEqual(job.payload.message);
     expect(rematerialized.data).toEqual(job.payload.data);
+    expect(job.replayKeys).toEqual(["default:ch-1:m-1"]);
   });
 
   it("preserves Carbon message getters across queued jobs", async () => {

extensions/discord/src/monitor/inbound-job.ts

@@ -22,6 +22,7 @@ export type DiscordInboundJob = {
   queueKey: string;
   payload: DiscordInboundJobPayload;
   runtime: DiscordInboundJobRuntime;
+  replayKeys?: string[];
 };
 
 export function resolveDiscordInboundJobQueueKey(ctx: DiscordMessagePreflightContext): string {
@@ -36,7 +37,10 @@ export function resolveDiscordInboundJobQueueKey(ctx: DiscordMessagePreflightCon
   return ctx.messageChannelId;
 }
 
-export function buildDiscordInboundJob(ctx: DiscordMessagePreflightContext): DiscordInboundJob {
+export function buildDiscordInboundJob(
+  ctx: DiscordMessagePreflightContext,
+  options?: { replayKeys?: readonly string[] },
+): DiscordInboundJob {
   const {
     runtime,
     abortSignal,
@@ -70,6 +74,7 @@ export function buildDiscordInboundJob(ctx: DiscordMessagePreflightContext): Dis
       threadBindings,
       discordRestFetch,
     },
+    replayKeys: options?.replayKeys ? [...options.replayKeys] : undefined,
   };
 }
 

extensions/discord/src/monitor/inbound-worker.ts

@@ -1,7 +1,14 @@
 import { createRunStateMachine } from "openclaw/plugin-sdk/channel-lifecycle";
 import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
+import type { ClaimableDedupe } from "openclaw/plugin-sdk/persistent-dedupe";
 import { danger, formatDurationSeconds } from "openclaw/plugin-sdk/runtime-env";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+import {
+  commitDiscordInboundReplay,
+  createDiscordInboundReplayGuard,
+  DiscordRetryableInboundError,
+  releaseDiscordInboundReplay,
+} from "./inbound-dedupe.js";
 import { materializeDiscordInboundJob, type DiscordInboundJob } from "./inbound-job.js";
 import type { RuntimeEnv } from "./message-handler.preflight.types.js";
 import { processDiscordMessage } from "./message-handler.process.js";
@@ -15,6 +22,7 @@ type DiscordInboundWorkerParams = {
   setStatus?: DiscordMonitorStatusSink;
   abortSignal?: AbortSignal;
   runTimeoutMs?: number;
+  replayGuard?: ClaimableDedupe;
   __testing?: DiscordInboundWorkerTestingHooks;
 };
 
@@ -46,6 +54,7 @@ async function processDiscordInboundJob(params: {
   runtime: RuntimeEnv;
   lifecycleSignal?: AbortSignal;
   runTimeoutMs?: number;
+  replayGuard: ClaimableDedupe;
   testing?: DiscordInboundWorkerTestingHooks;
 }) {
   const timeoutMs = normalizeDiscordInboundWorkerTimeoutMs(params.runTimeoutMs);
@@ -54,50 +63,70 @@ async function processDiscordInboundJob(params: {
   let createdThreadId: string | undefined;
   let sessionKey: string | undefined;
   const processDiscordMessageImpl = params.testing?.processDiscordMessage ?? processDiscordMessage;
-  await runDiscordTaskWithTimeout({
-    run: async (abortSignal) => {
-      await processDiscordMessageImpl(materializeDiscordInboundJob(params.job, abortSignal), {
-        onFinalReplyStart: () => {
-          finalReplyStarted = true;
-        },
-        onFinalReplyDelivered: () => {
-          finalReplyStarted = true;
-        },
-        onReplyPlanResolved: (resolved) => {
-          createdThreadId = normalizeOptionalString(resolved.createdThreadId);
-          sessionKey = normalizeOptionalString(resolved.sessionKey);
-        },
+  try {
+    await runDiscordTaskWithTimeout({
+      run: async (abortSignal) => {
+        await processDiscordMessageImpl(materializeDiscordInboundJob(params.job, abortSignal), {
+          onFinalReplyStart: () => {
+            finalReplyStarted = true;
+          },
+          onFinalReplyDelivered: () => {
+            finalReplyStarted = true;
+          },
+          onReplyPlanResolved: (resolved) => {
+            createdThreadId = normalizeOptionalString(resolved.createdThreadId);
+            sessionKey = normalizeOptionalString(resolved.sessionKey);
+          },
+        });
+      },
+      timeoutMs,
+      abortSignals: [params.job.runtime.abortSignal, params.lifecycleSignal],
+      onTimeout: async (resolvedTimeoutMs) => {
+        params.runtime.error?.(
+          danger(
+            `discord inbound worker timed out after ${formatDurationSeconds(resolvedTimeoutMs, {
+              decimals: 1,
+              unit: "seconds",
+            })}${contextSuffix}`,
+          ),
+        );
+        if (finalReplyStarted) {
+          return;
+        }
+        await sendDiscordInboundWorkerTimeoutReply({
+          job: params.job,
+          runtime: params.runtime,
+          contextSuffix,
+          createdThreadId,
+          sessionKey,
+          deliverDiscordReplyImpl: params.testing?.deliverDiscordReply,
+        });
+      },
+      onErrorAfterTimeout: (error) => {
+        params.runtime.error?.(
+          danger(`discord inbound worker failed after timeout: ${String(error)}${contextSuffix}`),
+        );
+      },
+    });
+    await commitDiscordInboundReplay({
+      replayKeys: params.job.replayKeys,
+      replayGuard: params.replayGuard,
+    });
+  } catch (error) {
+    if (error instanceof DiscordRetryableInboundError) {
+      releaseDiscordInboundReplay({
+        replayKeys: params.job.replayKeys,
+        error,
+        replayGuard: params.replayGuard,
       });
-    },
-    timeoutMs,
-    abortSignals: [params.job.runtime.abortSignal, params.lifecycleSignal],
-    onTimeout: async (resolvedTimeoutMs) => {
-      params.runtime.error?.(
-        danger(
-          `discord inbound worker timed out after ${formatDurationSeconds(resolvedTimeoutMs, {
-            decimals: 1,
-            unit: "seconds",
-          })}${contextSuffix}`,
-        ),
-      );
-      if (finalReplyStarted) {
-        return;
-      }
-      await sendDiscordInboundWorkerTimeoutReply({
-        job: params.job,
-        runtime: params.runtime,
-        contextSuffix,
-        createdThreadId,
-        sessionKey,
-        deliverDiscordReplyImpl: params.testing?.deliverDiscordReply,
+    } else {
+      await commitDiscordInboundReplay({
+        replayKeys: params.job.replayKeys,
+        replayGuard: params.replayGuard,
       });
-    },
-    onErrorAfterTimeout: (error) => {
-      params.runtime.error?.(
-        danger(`discord inbound worker failed after timeout: ${String(error)}${contextSuffix}`),
-      );
-    },
-  });
+    }
+    throw error;
+  }
 }
 
 async function sendDiscordInboundWorkerTimeoutReply(params: {
@@ -163,6 +192,7 @@ export function createDiscordInboundWorker(
     setStatus: params.setStatus,
     abortSignal: params.abortSignal,
   });
+  const replayGuard = params.replayGuard ?? createDiscordInboundReplayGuard();
 
   return {
     enqueue(job) {
@@ -181,6 +211,7 @@ export function createDiscordInboundWorker(
               runtime: params.runtime,
               lifecycleSignal: params.abortSignal,
               runTimeoutMs: params.runTimeoutMs,
+              replayGuard,
               testing: params.__testing,
             });
           } finally {