Auto-merge upstream openclaw/openclaw

Author: friuns2

CHANGELOG.md

@@ -4,27 +4,28 @@ Docs: https://docs.openclaw.ai
 
 ## Unreleased
 
-- fix(ui): replace marked.js with markdown-it to fix ReDoS UI freeze (#46707) thanks @zhangfnf
+- UI/chat: replace marked.js with markdown-it so maliciously crafted markdown can no longer freeze the Control UI via ReDoS. (#46707) Thanks @zhangfnf.
 
 ### Changes
 
 - Telegram/forum topics: surface human topic names in agent context, prompt metadata, and plugin hook metadata by learning names from Telegram forum service messages. (#65973) Thanks @ptahdunbar.
 
 ### Fixes
 
-- fix(heartbeat): force owner downgrade for untrusted hook:wake system events [AI-assisted]. (#66031) Thanks @pgondhi987.
-- fix(browser): enforce SSRF policy on snapshot, screenshot, and tab routes [AI]. (#66040) Thanks @pgondhi987.
-- fix(msteams): enforce sender allowlist checks on SSO signin invokes [AI]. (#66033) Thanks @pgondhi987.
-- fix(config): redact sourceConfig and runtimeConfig alias fields in redactConfigSnapshot [AI]. (#66030) Thanks @pgondhi987.
-- 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
+- Auto-reply/send policy: keep `sendPolicy: "deny"` from blocking inbound message processing, so the agent still runs its turn while all outbound delivery is suppressed for observer-style setups. (#65461, #53328) Thanks @omarshahine.
+- BlueBubbles: lazy-refresh the Private API server-info cache on send when reply threading or message effects are requested but status is unknown, so sends no longer silently degrade to plain messages when the 10-minute cache expires. (#65447, #43764) Thanks @omarshahine.
+- Heartbeat/security: force owner downgrade for untrusted `hook:wake` system events [AI-assisted]. (#66031) Thanks @pgondhi987.
+- Browser/security: enforce SSRF policy on snapshot, screenshot, and tab routes [AI]. (#66040) Thanks @pgondhi987.
+- Microsoft Teams/security: enforce sender allowlist checks on SSO signin invokes [AI]. (#66033) Thanks @pgondhi987.
+- Config/security: redact `sourceConfig` and `runtimeConfig` alias fields in `redactConfigSnapshot` [AI]. (#66030) Thanks @pgondhi987.
+- 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.
 - Heartbeat/Telegram topics: keep isolated heartbeat replies on the bound forum topic when `target=last`, instead of dropping them into the group root chat. (#66035) Thanks @mbelinky.
 - Browser/CDP: let managed local Chrome readiness, status probes, and managed loopback CDP control bypass browser SSRF policy for their own loopback control plane, so OpenClaw no longer misclassifies a healthy child browser as "not reachable after start". (#65695, #66043) Thanks @mbelinky.
-- Gateway/sessions: stop heartbeat, cron-event, and exec-event turns from overwriting shared-session routing and origin metadata, preventing synthetic `heartbeat` targets from poisoning later cron or user delivery. (#63733, #35300)
+- Gateway/sessions: stop heartbeat, cron-event, and exec-event turns from overwriting shared-session routing and origin metadata, preventing synthetic `heartbeat` targets from poisoning later cron or user delivery. (#66073, #63733, #35300) Thanks @mbelinky.
 - Browser/CDP: let local attach-only `manual-cdp` profiles reuse the local loopback CDP control plane under strict default policy and remote-class probe timeouts, so tabs/snapshot stop falsely reporting a live local browser session as not running. (#65611, #66080) Thanks @mbelinky.
 - Cron/scheduler: stop inventing short retries when cron next-run calculation returns no valid future slot, and keep a maintenance wake armed so enabled unscheduled jobs recover without entering a refire loop. (#66019, #66083) Thanks @mbelinky.
 - Cron/scheduler: preserve the active error-backoff floor when maintenance repair recomputes a missing cron next-run, so recurring errored jobs do not resume early after a transient next-run resolution failure. (#66019, #66083, #66113) Thanks @mbelinky.
@@ -33,11 +34,15 @@ Docs: https://docs.openclaw.ai
 - Dreaming/memory-core: require a live queued Dreaming cron event before the heartbeat hook runs the sweep, so managed Dreaming no longer replays on later heartbeats after the scheduled run was already consumed. (#66139) Thanks @mbelinky.
 - Control UI/Dreaming: stop Imported Insights and Memory Palace from calling optional `memory-wiki` gateway methods when the plugin is off, and refresh config before wiki reloads so the Dreaming tab stops showing misleading unknown-method failures. (#66140) Thanks @mbelinky.
 - Agents/tools: only mark streamed unknown-tool retries as counted when a streamed message actually classifies an unavailable tool, and keep incomplete streamed tool names from resetting the retry streak before the final assistant message arrives. (#66145) Thanks @dutifulbob.
-- Memory/active-memory: move recalled memory onto the hidden untrusted prompt-prefix path instead of system prompt injection, label the visible Active Memory status line fields, and include the resolved recall provider/model in gateway debug logs so trace/debug output matches what the model actually saw.
+- Memory/active-memory: move recalled memory onto the hidden untrusted prompt-prefix path instead of system prompt injection, label the visible Active Memory status line fields, and include the resolved recall provider/model in gateway debug logs so trace/debug output matches what the model actually saw. (#66144) Thanks @Takhoffman.
 - Memory/QMD: stop treating legacy lowercase `memory.md` as a second default root collection, so QMD recall no longer searches phantom `memory-alt-*` collections and builtin/QMD root-memory fallback stays aligned. (#66141) Thanks @mbelinky.
-- Agents/OpenAI: map `minimal` thinking to OpenAI's supported `low` reasoning effort for GPT-5.4 requests, so embedded runs stop failing request validation.
+- Agents/OpenAI: map `minimal` thinking to OpenAI's supported `low` reasoning effort for GPT-5.4 requests, so embedded runs stop failing request validation. Thanks @steipete.
 - Voice-call/media-stream: resolve the source IP from trusted forwarding headers for per-IP pending-connection limits when `webhookSecurity.trustForwardingHeaders` and `trustedProxyIPs` are configured, and reserve `maxConnections` capacity for in-flight WebSocket upgrades so concurrent handshakes can no longer momentarily exceed the operator-set cap. (#66027) Thanks @eleqtrizit.
 - Feishu/allowlist: canonicalize allowlist entries by explicit `user`/`chat` kind, strip repeated `feishu:`/`lark:` provider prefixes, and stop folding opaque Feishu IDs to lowercase, so allowlist matching no longer crosses user/chat namespaces or widens to case-insensitive ID matches the operator did not intend. (#66021) Thanks @eleqtrizit.
+- TTS/reply media: persist OpenClaw temp voice outputs into managed outbound media and allow them through reply-media normalization, so voice-note replies stop silently dropping. (#63511) Thanks @jetd1.
+- Agents/OpenAI: recover embedded GPT-style runs when reasoning-only or empty turns need bounded continuation, with replay-safe retry gating and incomplete-turn fallback when no visible answer arrives. (#66167) thanks @jalehman
+- Outbound/relay-status: suppress internal relay-status placeholder payloads (`No channel reply.`, `Replied in-thread.`, `Replied in #...`, wiki-update status variants ending in `No channel reply.`) before channel delivery so internal housekeeping text does not leak to users.
+- Slack/doctor: add a dedicated doctor-contract sidecar so config warmup paths such as `openclaw cron` no longer fall back to Slack's broader contract surface, which could trigger Slack-related config-read crashes on affected setups. (#63192) Thanks @shhtheonlyperson.
 
 ## 2026.4.12
 
@@ -118,6 +123,7 @@ Docs: https://docs.openclaw.ai
 - Agents/CLI: keep unrelated config, session, transcript, and MCP bootstrap runtime off common `openclaw agent` cold paths so provider selection and agent startup stop stalling on heavyweight imports. Thanks @vincentkoc.
 - Setup/config/install: stop setup, config dry-runs, and daemon install from eagerly booting auth-profile and plugin repair runtime when those paths are not needed, so onboarding and local service setup avoid long cold-start stalls. Thanks @vincentkoc.
 - Cron/direct delivery: slim isolated-agent delivery cold paths so direct channel delivery and related cron execution spend less time loading unrelated auth, plugin, and channel runtime. Thanks @vincentkoc.
+- Channels/replay dedupe: standardize replay claims, retryable-failure release, and post-success commit behavior across Telegram, Discord, Slack, Mattermost, WhatsApp, Matrix, LINE, Feishu, Zalo, Nextcloud Talk, TLON, Nostr, Voice Call, and shared plugin interactive callbacks so duplicate deliveries stay reply-once after success but retry cleanly after pre-delivery failures. Thanks @vincentkoc.
 
 ## 2026.4.11
 

extensions/qa-lab/src/mock-openai-server.test.ts

@@ -4,13 +4,65 @@ import { resolveProviderVariant, startQaMockOpenAiServer } from "./mock-openai-s
 const cleanups: Array<() => Promise<void>> = [];
 const QA_IMAGE_PNG_BASE64 =
   "iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAIAAAAlC+aJAAAAT0lEQVR42u3RQQkAMAzAwPg33Wnos+wgBo40dboAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANYADwAAAAAAAAAAAAAAAAAAAAAAAAAAAAC+Azy47PDiI4pA2wAAAABJRU5ErkJggg==";
+const QA_REASONING_ONLY_RECOVERY_PROMPT =
+  "Reasoning-only continuation QA check: read QA_KICKOFF_TASK.md, then answer with exactly REASONING-RECOVERED-OK.";
+const QA_REASONING_ONLY_SIDE_EFFECT_PROMPT =
+  "Reasoning-only after write safety check: write reasoning-only-side-effect.txt, then answer with exactly SIDE-EFFECT-GUARD-OK.";
+const QA_EMPTY_RESPONSE_RECOVERY_PROMPT =
+  "Empty response continuation QA check: read QA_KICKOFF_TASK.md, then answer with exactly EMPTY-RECOVERED-OK.";
+const QA_EMPTY_RESPONSE_EXHAUSTION_PROMPT =
+  "Empty response exhaustion QA check: read QA_KICKOFF_TASK.md, then answer with exactly EMPTY-EXHAUSTED-OK.";
+const QA_REASONING_ONLY_RETRY_INSTRUCTION =
+  "The previous assistant turn recorded reasoning but did not produce a user-visible answer. Continue from that partial turn and produce the visible answer now. Do not restate the reasoning or restart from scratch.";
+const QA_EMPTY_RESPONSE_RETRY_INSTRUCTION =
+  "The previous attempt did not produce a user-visible answer. Continue from the current state and produce the visible answer now. Do not restart from scratch.";
 
 afterEach(async () => {
   while (cleanups.length > 0) {
     await cleanups.pop()?.();
   }
 });
 
+async function startMockServer() {
+  const server = await startQaMockOpenAiServer({
+    host: "127.0.0.1",
+    port: 0,
+  });
+  cleanups.push(async () => {
+    await server.stop();
+  });
+  return server;
+}
+
+async function postResponses(server: { baseUrl: string }, body: unknown) {
+  return fetch(`${server.baseUrl}/v1/responses`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(body),
+  });
+}
+
+async function expectResponsesText(server: { baseUrl: string }, body: unknown) {
+  const response = await postResponses(server, body);
+  expect(response.status).toBe(200);
+  return response.text();
+}
+
+async function expectResponsesJson<T>(server: { baseUrl: string }, body: unknown) {
+  const response = await postResponses(server, body);
+  expect(response.status).toBe(200);
+  return (await response.json()) as T;
+}
+
+function makeUserInput(text: string) {
+  return {
+    role: "user" as const,
+    content: [{ type: "input_text" as const, text }],
+  };
+}
+
 describe("qa mock openai server", () => {
   it("serves health and streamed responses", async () => {
     const server = await startQaMockOpenAiServer({
@@ -1750,6 +1802,204 @@ describe("qa mock openai server", () => {
     const debug = (await debugResponse.json()) as { model: string };
     expect(debug.model).toBe("claude-opus-4-6");
   });
+
+  it("scripts a reasoning-only recovery sequence after a replay-safe read", async () => {
+    const server = await startMockServer();
+
+    const toolPlan = await expectResponsesText(server, {
+      stream: true,
+      model: "gpt-5.4",
+      input: [makeUserInput(QA_REASONING_ONLY_RECOVERY_PROMPT)],
+    });
+    expect(toolPlan).toContain('"name":"read"');
+    expect(toolPlan).toContain("QA_KICKOFF_TASK.md");
+
+    expect(
+      await expectResponsesJson<{
+        output?: Array<{ type?: string; id?: string; summary?: Array<{ text?: string }> }>;
+      }>(server, {
+        stream: false,
+        model: "gpt-5.4",
+        input: [
+          makeUserInput(QA_REASONING_ONLY_RECOVERY_PROMPT),
+          {
+            type: "function_call_output",
+            output: "QA mission: Understand this OpenClaw repo from source + docs before acting.",
+          },
+        ],
+      }),
+    ).toMatchObject({
+      output: [
+        {
+          type: "reasoning",
+          id: "rs_mock_reasoning_recovery",
+          summary: [{ text: expect.stringContaining("Need visible answer") }],
+        },
+      ],
+    });
+
+    expect(
+      await expectResponsesJson<{
+        output?: Array<{ content?: Array<{ text?: string }> }>;
+      }>(server, {
+        stream: false,
+        model: "gpt-5.4",
+        input: [
+          makeUserInput(QA_REASONING_ONLY_RECOVERY_PROMPT),
+          makeUserInput(QA_REASONING_ONLY_RETRY_INSTRUCTION),
+          {
+            type: "function_call_output",
+            output: "QA mission: Understand this OpenClaw repo from source + docs before acting.",
+          },
+        ],
+      }),
+    ).toMatchObject({
+      output: [
+        {
+          content: [{ text: "REASONING-RECOVERED-OK" }],
+        },
+      ],
+    });
+
+    const requests = await fetch(`${server.baseUrl}/debug/requests`);
+    expect(requests.status).toBe(200);
+    expect(await requests.json()).toMatchObject([
+      { plannedToolName: "read" },
+      { allInputText: expect.stringContaining(QA_REASONING_ONLY_RECOVERY_PROMPT) },
+      { allInputText: expect.stringContaining(QA_REASONING_ONLY_RETRY_INSTRUCTION) },
+    ]);
+  });
+
+  it("keeps the reasoning-only side-effect path ready for no-auto-retry QA coverage", async () => {
+    const server = await startMockServer();
+
+    const toolPlan = await expectResponsesText(server, {
+      stream: true,
+      model: "gpt-5.4",
+      input: [makeUserInput(QA_REASONING_ONLY_SIDE_EFFECT_PROMPT)],
+    });
+    expect(toolPlan).toContain('"name":"write"');
+    expect(toolPlan).toContain("reasoning-only-side-effect.txt");
+
+    expect(
+      await expectResponsesJson<{
+        output?: Array<{ type?: string; id?: string }>;
+      }>(server, {
+        stream: false,
+        model: "gpt-5.4",
+        input: [
+          makeUserInput(QA_REASONING_ONLY_SIDE_EFFECT_PROMPT),
+          {
+            type: "function_call_output",
+            output: "Successfully wrote 28 bytes to reasoning-only-side-effect.txt.",
+          },
+        ],
+      }),
+    ).toMatchObject({
+      output: [{ type: "reasoning", id: "rs_mock_reasoning_side_effect" }],
+    });
+
+    const requests = await fetch(`${server.baseUrl}/debug/requests`);
+    expect(requests.status).toBe(200);
+    expect((await requests.json()) as Array<{ allInputText?: string }>).toHaveLength(2);
+  });
+
+  it("scripts an empty-response recovery sequence after a replay-safe read", async () => {
+    const server = await startMockServer();
+
+    const toolPlan = await expectResponsesText(server, {
+      stream: true,
+      model: "gpt-5.4",
+      input: [makeUserInput(QA_EMPTY_RESPONSE_RECOVERY_PROMPT)],
+    });
+    expect(toolPlan).toContain('"name":"read"');
+
+    expect(
+      await expectResponsesJson<{
+        output?: Array<{ content?: Array<{ type?: string; text?: string }> }>;
+      }>(server, {
+        stream: false,
+        model: "gpt-5.4",
+        input: [
+          makeUserInput(QA_EMPTY_RESPONSE_RECOVERY_PROMPT),
+          {
+            type: "function_call_output",
+            output: "QA mission: Understand this OpenClaw repo from source + docs before acting.",
+          },
+        ],
+      }),
+    ).toMatchObject({
+      output: [
+        {
+          content: [{ type: "output_text", text: "" }],
+        },
+      ],
+    });
+
+    expect(
+      await expectResponsesJson<{
+        output?: Array<{ content?: Array<{ text?: string }> }>;
+      }>(server, {
+        stream: false,
+        model: "gpt-5.4",
+        input: [
+          makeUserInput(QA_EMPTY_RESPONSE_RECOVERY_PROMPT),
+          makeUserInput(QA_EMPTY_RESPONSE_RETRY_INSTRUCTION),
+          {
+            type: "function_call_output",
+            output: "QA mission: Understand this OpenClaw repo from source + docs before acting.",
+          },
+        ],
+      }),
+    ).toMatchObject({
+      output: [
+        {
+          content: [{ text: "EMPTY-RECOVERED-OK" }],
+        },
+      ],
+    });
+  });
+
+  it("can keep emitting empty GPT turns when the single retry budget should exhaust", async () => {
+    const server = await startMockServer();
+
+    await expectResponsesText(server, {
+      stream: true,
+      model: "gpt-5.4",
+      input: [makeUserInput(QA_EMPTY_RESPONSE_EXHAUSTION_PROMPT)],
+    });
+
+    const firstEmpty = await expectResponsesJson<{
+      output?: Array<{ content?: Array<{ text?: string }> }>;
+    }>(server, {
+      stream: false,
+      model: "gpt-5.4",
+      input: [
+        makeUserInput(QA_EMPTY_RESPONSE_EXHAUSTION_PROMPT),
+        {
+          type: "function_call_output",
+          output: "QA mission: Understand this OpenClaw repo from source + docs before acting.",
+        },
+      ],
+    });
+    expect(firstEmpty.output?.[0]?.content?.[0]?.text).toBe("");
+
+    const secondEmpty = await expectResponsesJson<{
+      output?: Array<{ content?: Array<{ text?: string }> }>;
+    }>(server, {
+      stream: false,
+      model: "gpt-5.4",
+      input: [
+        makeUserInput(QA_EMPTY_RESPONSE_EXHAUSTION_PROMPT),
+        makeUserInput(QA_EMPTY_RESPONSE_RETRY_INSTRUCTION),
+        {
+          type: "function_call_output",
+          output: "QA mission: Understand this OpenClaw repo from source + docs before acting.",
+        },
+      ],
+    });
+    expect(secondEmpty.output?.[0]?.content?.[0]?.text).toBe("");
+  });
 });
 
 describe("resolveProviderVariant", () => {