Auto-merge upstream openclaw/openclaw

Author: friuns2

CHANGELOG.md

@@ -95,6 +95,7 @@ Docs: https://docs.openclaw.ai
 - Agents/BTW: strip replayed tool blocks, hidden reasoning, and malformed image payloads from `/btw` side-question context so Bedrock no-tools side questions keep working after tool-use turns. (#64225) Thanks @ngutman.
 - Commands/btw: keep tool-less side questions from sending injected empty `tools` arrays on strict OpenAI-compatible providers, so `/btw` continues working after prior tool-call history. (#64219) Thanks @ngutman.
 - Agents/Bedrock: let `/btw` side questions use `auth: "aws-sdk"` without a static API key so Bedrock IAM and instance-role sessions stop failing before the side question runs. (#64218) Thanks @SnowSky1.
+- Feishu: route `/btw` side questions and `/stop` onto bounded out-of-band lanes so BTW no longer waits behind a busy normal chat turn while ordinary same-chat traffic stays FIFO. (#64324) Thanks @ngutman.
 - Agents/failover: detect llama.cpp slot context overflows as context-overflow errors so compaction can retry self-hosted OpenAI-compatible runs instead of surfacing the raw upstream 400. (#64196) Thanks @alexander-applyinnovations.
 - Claude CLI/skills: pass eligible OpenClaw skills into CLI runs, including native Claude Code skill resolution via a temporary plugin plus per-run skill env/API key injection. (#62686, #62723) Thanks @zomars.
 - Discord: keep generated auto-thread names working with reasoning models by giving title generation enough output budget for thinking plus visible title text. (#64172) Thanks @hanamizuki.
@@ -106,6 +107,7 @@ Docs: https://docs.openclaw.ai
 - Discord/TTS: route auto voice replies through the native voice-note path so Discord receives Opus voice messages instead of regular audio attachments. (#64096) Thanks @LiuHuaize.
 - Config/plugins: use plugin-owned command alias metadata when `plugins.allow` contains runtime command names like `dreaming`, and point users at the owning plugin instead of stale plugin-not-found guidance. (#64242) Thanks @feiskyer.
 - Agents/Gemini: strip orphaned `required` entries from Gemini tool schemas so provider validation no longer rejects tools after schema cleanup or union flattening. (#64284) Thanks @xxxxxmax.
+- Assistant text: strip Qwen-style XML tool call payloads from visible replies so web and channel messages no longer show raw `<tool_call><function=...>` output. (#64214) Thanks @MoerAI.
 
 ## 2026.4.9
 

docs/reference/templates/AGENTS.md

@@ -136,9 +136,6 @@ Skills provide your tools. When you need one, check its `SKILL.md`. Keep local n
 
 When you receive a heartbeat poll (message matches the configured heartbeat prompt), don't just reply `HEARTBEAT_OK` every time. Use heartbeats productively!
 
-Default heartbeat prompt:
-`Read HEARTBEAT.md if it exists (workspace context). Follow it strictly. Do not infer or repeat old tasks from prior chats. If nothing needs attention, reply HEARTBEAT_OK.`
-
 You are free to edit `HEARTBEAT.md` with a short checklist or reminders. Keep it small to limit token burn.
 
 ### Heartbeat vs Cron: When to Use Each

extensions/feishu/src/client.ts

@@ -1,8 +1,22 @@
 import type { Agent } from "node:https";
+import { createRequire } from "node:module";
 import * as Lark from "@larksuiteoapi/node-sdk";
 import { resolveAmbientNodeProxyAgent } from "openclaw/plugin-sdk/extension-shared";
 import type { FeishuConfig, FeishuDomain, ResolvedFeishuAccount } from "./types.js";
 
+const require = createRequire(import.meta.url);
+const { version: pluginVersion } = require("../package.json") as { version: string };
+
+export { pluginVersion };
+
+const FEISHU_USER_AGENT = `openclaw-feishu-builtin/${pluginVersion}/${process.platform}`;
+export { FEISHU_USER_AGENT };
+
+/** User-Agent header value for all Feishu API requests. */
+export function getFeishuUserAgent(): string {
+  return FEISHU_USER_AGENT;
+}
+
 type FeishuClientSdk = Pick<
   typeof Lark,
   | "AppType"
@@ -26,6 +40,35 @@ const defaultFeishuClientSdk: FeishuClientSdk = {
 
 let feishuClientSdk: FeishuClientSdk = defaultFeishuClientSdk;
 
+// Override the SDK's default User-Agent interceptor.
+// The Lark SDK registers an axios request interceptor that sets
+// 'oapi-node-sdk/1.0.0'. Axios request interceptors execute in LIFO order
+// (last-registered runs first), so simply appending ours doesn't work — the
+// SDK's interceptor would run last and overwrite our UA. We must clear
+// handlers[] first, then register our own as the sole interceptor.
+//
+// Risk is low: the SDK only registers one interceptor (UA) at init time, and
+// we clear it at module load before any other code can register handlers.
+// If a future SDK version adds more interceptors, the upgrade will need
+// compatibility verification regardless.
+{
+  const inst = Lark.defaultHttpInstance as {
+    interceptors?: {
+      request: { handlers: unknown[]; use: (fn: (req: unknown) => unknown) => void };
+    };
+  };
+  if (inst.interceptors?.request) {
+    inst.interceptors.request.handlers = [];
+    inst.interceptors.request.use((req: unknown) => {
+      const r = req as { headers?: Record<string, string> };
+      if (r.headers) {
+        r.headers["User-Agent"] = getFeishuUserAgent();
+      }
+      return req;
+    });
+  }
+}
+
 /** Default HTTP timeout for Feishu API requests (30 seconds). */
 export const FEISHU_HTTP_TIMEOUT_MS = 30_000;
 export const FEISHU_HTTP_TIMEOUT_MAX_MS = 300_000;
@@ -36,7 +79,7 @@ type FeishuHttpInstanceLike = Pick<
   "request" | "get" | "post" | "put" | "patch" | "delete" | "head" | "options"
 >;
 
-async function getWsProxyAgent(): Promise<Agent | undefined> {
+async function getWsProxyAgent() {
   return resolveAmbientNodeProxyAgent<Agent>();
 }
 
@@ -61,8 +104,8 @@ function resolveDomain(domain: FeishuDomain | undefined): Lark.Domain | string {
 
 /**
  * Create an HTTP instance that delegates to the Lark SDK's default instance
- * but injects a default request timeout to prevent indefinite hangs
- * (e.g. when the Feishu API is slow, causing per-chat queue deadlocks).
+ * but injects a default request timeout and User-Agent header to prevent
+ * indefinite hangs and set a standardized User-Agent per OAPI best practices.
  */
 function createTimeoutHttpInstance(defaultTimeoutMs: number): Lark.HttpInstance {
   const base: FeishuHttpInstanceLike = feishuClientSdk.defaultHttpInstance;

extensions/feishu/src/monitor.account.ts

@@ -29,6 +29,8 @@ import { botNames, botOpenIds } from "./monitor.state.js";
 import { monitorWebhook, monitorWebSocket } from "./monitor.transport.js";
 import { getFeishuRuntime } from "./runtime.js";
 import { getMessageFeishu } from "./send.js";
+import { getFeishuSequentialKey } from "./sequential-key.js";
+import { createSequentialQueue } from "./sequential-queue.js";
 import { createFeishuThreadBindingManager } from "./thread-bindings.js";
 import type { FeishuChatType, ResolvedFeishuAccount } from "./types.js";
 
@@ -290,25 +292,6 @@ function parseFeishuCardActionEventPayload(value: unknown): FeishuCardActionEven
   };
 }
 
-/**
- * Per-chat serial queue that ensures messages from the same chat are processed
- * in arrival order while allowing different chats to run concurrently.
- */
-function createChatQueue() {
-  const queues = new Map<string, Promise<void>>();
-  return (chatId: string, task: () => Promise<void>): Promise<void> => {
-    const prev = queues.get(chatId) ?? Promise.resolve();
-    const next = prev.then(task, task);
-    queues.set(chatId, next);
-    void next.finally(() => {
-      if (queues.get(chatId) === next) {
-        queues.delete(chatId);
-      }
-    });
-    return next;
-  };
-}
-
 function mergeFeishuDebounceMentions(
   entries: FeishuMessageEvent[],
 ): FeishuMessageEvent["message"]["mentions"] | undefined {
@@ -395,7 +378,9 @@ function registerEventHandlers(
   });
   const log = runtime?.log ?? console.log;
   const error = runtime?.error ?? console.error;
-  const enqueue = createChatQueue();
+  // Keep normal Feishu traffic FIFO per chat while allowing explicit out-of-band
+  // commands like /btw and /stop to bypass the busy main-chat lane.
+  const enqueue = createSequentialQueue();
   const runFeishuHandler = async (params: { task: () => Promise<void>; errorMessage: string }) => {
     if (fireAndForget) {
       void params.task().catch((err) => {
@@ -410,7 +395,12 @@ function registerEventHandlers(
     }
   };
   const dispatchFeishuMessage = async (event: FeishuMessageEvent) => {
-    const chatId = event.message.chat_id?.trim() || "unknown";
+    const sequentialKey = getFeishuSequentialKey({
+      accountId,
+      event,
+      botOpenId: botOpenIds.get(accountId),
+      botName: botNames.get(accountId),
+    });
     const task = () =>
       handleFeishuMessage({
         cfg,
@@ -422,7 +412,7 @@ function registerEventHandlers(
         accountId,
         processingClaimHeld: true,
       });
-    await enqueue(chatId, task);
+    await enqueue(sequentialKey, task);
   };
   const resolveSenderDebounceId = (event: FeishuMessageEvent): string | undefined => {
     const senderId =

extensions/feishu/src/probe.test.ts

@@ -10,7 +10,7 @@ vi.mock("./client.js", () => ({
 const DEFAULT_CREDS = { appId: "cli_123", appSecret: "secret" } as const; // pragma: allowlist secret
 const DEFAULT_SUCCESS_RESPONSE = {
   code: 0,
-  bot: { bot_name: "TestBot", open_id: "ou_abc123" },
+  data: { pingBotInfo: { botName: "TestBot", botID: "ou_abc123" } },
 } as const;
 const DEFAULT_SUCCESS_RESULT = {
   ok: true,
@@ -20,7 +20,7 @@ const DEFAULT_SUCCESS_RESULT = {
 } as const;
 const BOT1_RESPONSE = {
   code: 0,
-  bot: { bot_name: "Bot1", open_id: "ou_1" },
+  data: { pingBotInfo: { botName: "Bot1", botID: "ou_1" } },
 } as const;
 
 function makeRequestFn(response: Record<string, unknown>) {
@@ -135,8 +135,9 @@ describe("probeFeishu", () => {
 
     expect(requestFn).toHaveBeenCalledWith(
       expect.objectContaining({
-        method: "GET",
-        url: "/open-apis/bot/v3/info",
+        method: "POST",
+        url: "/open-apis/bot/v1/openclaw_bot/ping",
+        data: { needBotInfo: true },
         timeout: FEISHU_PROBE_REQUEST_TIMEOUT_MS,
       }),
     );
@@ -259,10 +260,10 @@ describe("probeFeishu", () => {
     });
   });
 
-  it("handles response.data.bot fallback path", async () => {
+  it("handles response with pingBotInfo in data", async () => {
     setupClient({
       code: 0,
-      data: { bot: { bot_name: "DataBot", open_id: "ou_data" } },
+      data: { pingBotInfo: { botName: "DataBot", botID: "ou_data" } },
     });
 
     await expectDefaultSuccessResult(DEFAULT_CREDS, {

extensions/feishu/src/probe.ts

@@ -18,20 +18,19 @@ export type ProbeFeishuOptions = {
   abortSignal?: AbortSignal;
 };
 
-type FeishuBotInfoResponse = {
+type FeishuPingResponse = {
   code: number;
   msg?: string;
-  bot?: { bot_name?: string; open_id?: string };
-  data?: { bot?: { bot_name?: string; open_id?: string } };
+  data?: { pingBotInfo?: { botID?: string; botName?: string } };
 };
 
 type FeishuRequestClient = ReturnType<typeof createFeishuClient> & {
   request(params: {
-    method: "GET";
+    method: "POST";
     url: string;
-    data: Record<string, never>;
+    data: Record<string, unknown>;
     timeout: number;
-  }): Promise<FeishuBotInfoResponse>;
+  }): Promise<FeishuPingResponse>;
 };
 
 function setCachedProbeResult(
@@ -81,12 +80,14 @@ export async function probeFeishu(
 
   try {
     const client = createFeishuClient(creds) as FeishuRequestClient;
-    // Use bot/v3/info API to get bot information
-    const responseResult = await raceWithTimeoutAndAbort<FeishuBotInfoResponse>(
+    // Feishu-provided endpoint for OpenClaw, supported on both Feishu (CN)
+    // and Lark (international). No OAuth scopes required. Validates
+    // credentials and registers the app as an AI agent (智能体).
+    const responseResult = await raceWithTimeoutAndAbort<FeishuPingResponse>(
       client.request({
-        method: "GET",
-        url: "/open-apis/bot/v3/info",
-        data: {},
+        method: "POST",
+        url: "/open-apis/bot/v1/openclaw_bot/ping",
+        data: { needBotInfo: true },
         timeout: timeoutMs,
       }),
       {
@@ -135,14 +136,14 @@ export async function probeFeishu(
       );
     }
 
-    const bot = response.bot || response.data?.bot;
+    const botInfo = response.data?.pingBotInfo;
     return setCachedProbeResult(
       cacheKey,
       {
         ok: true,
         appId: creds.appId,
-        botName: bot?.bot_name,
-        botOpenId: bot?.open_id,
+        botName: botInfo?.botName,
+        botOpenId: botInfo?.botID,
       },
       PROBE_SUCCESS_TTL_MS,
     );

extensions/feishu/src/sequential-key.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import type { FeishuMessageEvent } from "./bot.js";
+import { getFeishuSequentialKey } from "./sequential-key.js";
+
+function createTextEvent(params: {
+  text: string;
+  messageId?: string;
+  chatId?: string;
+}): FeishuMessageEvent {
+  return {
+    sender: {
+      sender_id: {
+        open_id: "ou_sender_1",
+        user_id: "ou_user_1",
+      },
+      sender_type: "user",
+    },
+    message: {
+      message_id: params.messageId ?? "om_message_1",
+      chat_id: params.chatId ?? "oc_dm_chat",
+      chat_type: "p2p",
+      message_type: "text",
+      content: JSON.stringify({ text: params.text }),
+    },
+  } as FeishuMessageEvent;
+}
+
+describe("getFeishuSequentialKey", () => {
+  it.each([
+    [createTextEvent({ text: "hello" }), "feishu:default:oc_dm_chat"],
+    [createTextEvent({ text: "/status" }), "feishu:default:oc_dm_chat"],
+    [createTextEvent({ text: "/stop" }), "feishu:default:oc_dm_chat:control"],
+    [createTextEvent({ text: "/btw what changed?" }), "feishu:default:oc_dm_chat:btw"],
+  ])("resolves sequential key %#", (event, expected) => {
+    expect(
+      getFeishuSequentialKey({
+        accountId: "default",
+        event,
+      }),
+    ).toBe(expected);
+  });
+
+  it("keeps /btw on a stable per-chat lane across different message ids", () => {
+    const first = createTextEvent({ text: "/btw one", messageId: "om_message_1" });
+    const second = createTextEvent({ text: "/btw two", messageId: "om_message_2" });
+
+    expect(
+      getFeishuSequentialKey({
+        accountId: "default",
+        event: first,
+      }),
+    ).toBe("feishu:default:oc_dm_chat:btw");
+    expect(
+      getFeishuSequentialKey({
+        accountId: "default",
+        event: second,
+      }),
+    ).toBe("feishu:default:oc_dm_chat:btw");
+  });
+
+  it("falls back to a stable btw lane when the message id is unavailable", () => {
+    const event = createTextEvent({ text: "/btw what changed?" });
+    delete (event.message as { message_id?: string }).message_id;
+
+    expect(
+      getFeishuSequentialKey({
+        accountId: "default",
+        event,
+      }),
+    ).toBe("feishu:default:oc_dm_chat:btw");
+  });
+});

extensions/feishu/src/sequential-key.ts

@@ -0,0 +1,25 @@
+import { isAbortRequestText, isBtwRequestText } from "openclaw/plugin-sdk/reply-runtime";
+import { parseFeishuMessageEvent, type FeishuMessageEvent } from "./bot.js";
+
+export function getFeishuSequentialKey(params: {
+  accountId: string;
+  event: FeishuMessageEvent;
+  botOpenId?: string;
+  botName?: string;
+}): string {
+  const { accountId, event, botOpenId, botName } = params;
+  const chatId = event.message.chat_id?.trim() || "unknown";
+  const baseKey = `feishu:${accountId}:${chatId}`;
+  const parsed = parseFeishuMessageEvent(event, botOpenId, botName);
+  const text = parsed.content.trim();
+
+  if (isAbortRequestText(text)) {
+    return `${baseKey}:control`;
+  }
+
+  if (isBtwRequestText(text)) {
+    return `${baseKey}:btw`;
+  }
+
+  return baseKey;
+}