gewe-openclaw 2026.3.11 → 2026.3.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gewe-openclaw",
-  "version": "2026.3.11",
+  "version": "2026.3.12",
   "type": "module",
   "description": "OpenClaw GeWe channel plugin",
   "license": "MIT",

package/src/inbound-batch.ts

@@ -0,0 +1,188 @@
+import type { AgentMediaPayload, OpenClawConfig } from "openclaw/plugin-sdk";
+import { buildAgentMediaPayload } from "openclaw/plugin-sdk";
+
+import type { GeweInboundMessage } from "./types.js";
+
+const CHANNEL_ID = "gewe-openclaw" as const;
+const DEFAULT_GEWE_INBOUND_DEBOUNCE_MS = 1000;
+
+type DebounceBuffer = {
+  messages: GeweInboundMessage[];
+  timeout: ReturnType<typeof setTimeout> | null;
+  debounceMs: number;
+};
+
+function normalizeMs(value: unknown): number | undefined {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return undefined;
+  }
+  return Math.max(0, Math.trunc(value));
+}
+
+function resolveGroupConversationId(message: GeweInboundMessage): string | undefined {
+  if (message.fromId.endsWith("@chatroom")) {
+    return message.fromId;
+  }
+  if (message.toId.endsWith("@chatroom")) {
+    return message.toId;
+  }
+  return undefined;
+}
+
+export function resolveGeweInboundDebounceMs(cfg: OpenClawConfig): number {
+  const inbound = cfg.messages?.inbound;
+  const byChannel = normalizeMs(inbound?.byChannel?.[CHANNEL_ID]);
+  const global = normalizeMs(inbound?.debounceMs);
+  return byChannel ?? global ?? DEFAULT_GEWE_INBOUND_DEBOUNCE_MS;
+}
+
+export function buildGeweInboundDebounceKey(params: {
+  accountId: string;
+  message: GeweInboundMessage;
+}): string | null {
+  const conversationId = params.message.isGroupChat
+    ? resolveGroupConversationId(params.message)
+    : params.message.senderId || params.message.fromId || params.message.toId;
+  const senderId = params.message.senderId?.trim();
+  const accountId = params.accountId.trim();
+  if (!accountId || !conversationId || !senderId) {
+    return null;
+  }
+  return `${CHANNEL_ID}:${accountId}:${conversationId}:${senderId}`;
+}
+
+export function resolveGeweInboundDebounceText(message: GeweInboundMessage): string {
+  const text = message.text?.trim() ?? "";
+  if (text) {
+    return text;
+  }
+  if (message.msgType === 3) return "<media:image>";
+  if (message.msgType === 34) return "<media:audio>";
+  if (message.msgType === 43) return "<media:video>";
+  if (message.msgType === 49) return "<media:document>";
+  return "";
+}
+
+export function buildGeweInboundMessageMeta(messages: GeweInboundMessage[]): {
+  messageSid?: string;
+  messageSidFull?: string;
+  messageSids?: string[];
+  messageSidFirst?: string;
+  messageSidLast?: string;
+  timestamp?: number;
+} {
+  const ids = messages
+    .map((message) => message.newMessageId?.trim() || message.messageId?.trim())
+    .filter(Boolean) as string[];
+  const lastMessage = messages.at(-1);
+  const firstId = ids[0];
+  const lastId = ids.at(-1);
+
+  return {
+    messageSid: lastId,
+    messageSidFull: lastId,
+    messageSids: ids.length > 1 ? ids : undefined,
+    messageSidFirst: ids.length > 1 ? firstId : undefined,
+    messageSidLast: ids.length > 1 ? lastId : undefined,
+    timestamp: lastMessage?.timestamp,
+  };
+}
+
+export function buildGeweInboundMediaPayload(
+  mediaList: Array<{ path: string; contentType?: string | null }>,
+): AgentMediaPayload {
+  if (mediaList.length === 0) {
+    return {};
+  }
+  return buildAgentMediaPayload(mediaList);
+}
+
+export function createGeweInboundDebouncer(params: {
+  cfg: OpenClawConfig;
+  accountId: string;
+  isControlCommand: (text: string) => boolean;
+  onFlush: (messages: GeweInboundMessage[]) => Promise<void>;
+  onError?: (err: unknown, messages: GeweInboundMessage[]) => void;
+}) {
+  const buffers = new Map<string, DebounceBuffer>();
+
+  const flushBuffer = async (key: string, buffer: DebounceBuffer) => {
+    buffers.delete(key);
+    if (buffer.timeout) {
+      clearTimeout(buffer.timeout);
+      buffer.timeout = null;
+    }
+    if (buffer.messages.length === 0) {
+      return;
+    }
+    try {
+      await params.onFlush(buffer.messages);
+    } catch (err) {
+      params.onError?.(err, buffer.messages);
+    }
+  };
+
+  const flushKey = async (key: string) => {
+    const buffer = buffers.get(key);
+    if (!buffer) {
+      return;
+    }
+    await flushBuffer(key, buffer);
+  };
+
+  const scheduleFlush = (key: string, buffer: DebounceBuffer) => {
+    if (buffer.timeout) {
+      clearTimeout(buffer.timeout);
+    }
+    buffer.timeout = setTimeout(() => {
+      void flushBuffer(key, buffer);
+    }, buffer.debounceMs);
+    buffer.timeout.unref?.();
+  };
+
+  const enqueue = async (message: GeweInboundMessage) => {
+    const key = buildGeweInboundDebounceKey({
+      accountId: params.accountId,
+      message,
+    });
+    const debounceMs = resolveGeweInboundDebounceMs(params.cfg);
+    const canDebounce =
+      debounceMs > 0 && !params.isControlCommand(resolveGeweInboundDebounceText(message));
+
+    if (!canDebounce || !key) {
+      if (key && buffers.has(key)) {
+        await flushKey(key);
+      }
+      try {
+        await params.onFlush([message]);
+      } catch (err) {
+        params.onError?.(err, [message]);
+      }
+      return;
+    }
+
+    const existing = buffers.get(key);
+    if (existing) {
+      existing.messages.push(message);
+      existing.debounceMs = debounceMs;
+      scheduleFlush(key, existing);
+      return;
+    }
+
+    const buffer: DebounceBuffer = {
+      messages: [message],
+      timeout: null,
+      debounceMs,
+    };
+    buffers.set(key, buffer);
+    scheduleFlush(key, buffer);
+  };
+
+  const flushAll = async () => {
+    for (const [key, buffer] of [...buffers.entries()]) {
+      await flushBuffer(key, buffer);
+    }
+  };
+
+  return { enqueue, flushKey, flushAll };
+}

package/src/inbound.ts

@@ -6,6 +6,10 @@ import path from "node:path";
 import type { OpenClawConfig, ReplyPayload, RuntimeEnv } from "openclaw/plugin-sdk";
 import { logInboundDrop, resolveControlCommandGate } from "openclaw/plugin-sdk";
 
+import {
+  buildGeweInboundMediaPayload,
+  buildGeweInboundMessageMeta,
+} from "./inbound-batch.js";
 import type { GeweDownloadQueue } from "./download-queue.js";
 import { downloadGeweFile, downloadGeweImage, downloadGeweVideo, downloadGeweVoice } from "./download.js";
 import { deliverGewePayload } from "./delivery.js";
@@ -37,9 +41,21 @@ type PreparedInbound = {
   storePath: string;
   toWxid: string;
   messageSid: string;
+  messageSids?: string[];
+  messageSidFirst?: string;
+  messageSidLast?: string;
   timestamp?: number;
 };
 
+type NormalizedInboundEntry = {
+  message: GeweInboundMessage;
+  rawBody: string;
+  download?: {
+    msgType: number;
+    xml: string;
+  };
+};
+
 const DEFAULT_VOICE_SAMPLE_RATE = 24000;
 const DEFAULT_VOICE_DECODE_TIMEOUT_MS = 30_000;
 const SILK_HEADER = "#!SILK_V3";
@@ -364,15 +380,145 @@ function resolveMediaMaxBytes(account: ResolvedGeweAccount): number {
   return 20 * 1024 * 1024;
 }
 
+function resolveGroupConversationId(message: GeweInboundMessage): string | undefined {
+  if (message.fromId.endsWith("@chatroom")) {
+    return message.fromId;
+  }
+  if (message.toId.endsWith("@chatroom")) {
+    return message.toId;
+  }
+  return undefined;
+}
+
+function normalizeInboundEntry(params: {
+  message: GeweInboundMessage;
+  runtime: RuntimeEnv;
+}): NormalizedInboundEntry | null {
+  const { message, runtime } = params;
+  const msgType = message.msgType;
+  if (![1, 3, 34, 43, 49].includes(msgType)) {
+    runtime.log?.(`gewe: skip unsupported msgType ${msgType}`);
+    return null;
+  }
+
+  const { text, xml } = resolveInboundText(message);
+  const rawBodyCandidate = (msgType === 1 ? text.trim() : "") || resolveMediaPlaceholder(msgType);
+  if (!rawBodyCandidate.trim()) {
+    runtime.log?.("gewe: skip empty message");
+    return null;
+  }
+
+  if (msgType === 49 && xml) {
+    const appType = extractAppMsgType(xml);
+    if (appType === 5) {
+      return {
+        message,
+        rawBody: resolveLinkBody(xml) || rawBodyCandidate,
+      };
+    }
+    if (appType === 74) {
+      runtime.log?.("gewe: file notification received (skip download)");
+      return null;
+    }
+    if (appType !== 6) {
+      runtime.log?.(`gewe: unhandled appmsg type ${appType ?? "unknown"}`);
+      return null;
+    }
+  }
+
+  return {
+    message,
+    rawBody: rawBodyCandidate,
+    download:
+      (msgType === 3 || msgType === 34 || msgType === 43 || msgType === 49) && xml
+        ? { msgType, xml }
+        : undefined,
+  };
+}
+
+async function downloadInboundMediaEntry(params: {
+  entry: NormalizedInboundEntry;
+  account: ResolvedGeweAccount;
+  maxBytes: number;
+}): Promise<{ path: string; contentType?: string | null } | null> {
+  const { entry, account, maxBytes } = params;
+  const core = getGeweRuntime();
+  if (!entry.download) {
+    return null;
+  }
+
+  const { msgType, xml } = entry.download;
+  let fileUrl: string | null = null;
+  if (msgType === 3) {
+    try {
+      fileUrl = await downloadGeweImage({ account, xml, type: 2 });
+    } catch {
+      try {
+        fileUrl = await downloadGeweImage({ account, xml, type: 1 });
+      } catch {
+        fileUrl = await downloadGeweImage({ account, xml, type: 3 });
+      }
+    }
+  } else if (msgType === 34) {
+    fileUrl = await downloadGeweVoice({
+      account,
+      xml,
+      msgId: Number(entry.message.messageId),
+    });
+  } else if (msgType === 43) {
+    fileUrl = await downloadGeweVideo({ account, xml });
+  } else if (msgType === 49) {
+    fileUrl = await downloadGeweFile({ account, xml });
+  }
+
+  if (!fileUrl) {
+    return null;
+  }
+
+  const fetched = await core.channel.media.fetchRemoteMedia({
+    url: fileUrl,
+    maxBytes,
+    filePathHint: fileUrl,
+  });
+  let buffer = fetched.buffer;
+  let contentType = fetched.contentType;
+  let originalFilename = msgType === 49 ? extractFileName(xml) : fetched.fileName;
+
+  if (msgType === 34 && looksLikeSilkVoice({ buffer, contentType, fileName: originalFilename })) {
+    const decoded = await decodeSilkVoice({
+      account,
+      buffer,
+      fileName: originalFilename,
+    });
+    if (decoded) {
+      buffer = decoded.buffer;
+      contentType = decoded.contentType;
+      originalFilename = decoded.fileName;
+    }
+  }
+
+  const saved = await core.channel.media.saveMediaBuffer(
+    buffer,
+    contentType,
+    "inbound",
+    maxBytes,
+    originalFilename,
+  );
+  return {
+    path: saved.path,
+    contentType: saved.contentType,
+  };
+}
+
 async function dispatchGeweInbound(params: {
   prepared: PreparedInbound;
   account: ResolvedGeweAccount;
   config: CoreConfig;
   runtime: RuntimeEnv;
-  media?: { path?: string; contentType?: string };
+  mediaList?: Array<{ path: string; contentType?: string | null }>;
   statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
 }): Promise<void> {
-  const { prepared, account, config, runtime, media, statusSink } = params;
+  const { prepared, account, config, runtime, mediaList = [], statusSink } = params;
   const core = getGeweRuntime();
   const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(config as OpenClawConfig);
   const previousTimestamp = core.channel.session.readSessionUpdatedAt({
@@ -387,6 +533,7 @@ async function dispatchGeweInbound(params: {
     envelope: envelopeOptions,
     body: prepared.rawBody,
   });
+  const mediaPayload = buildGeweInboundMediaPayload(mediaList);
 
   const ctxPayload = core.channel.reply.finalizeInboundContext({
     Body: body,
@@ -409,9 +556,10 @@ async function dispatchGeweInbound(params: {
     Surface: CHANNEL_ID,
     MessageSid: prepared.messageSid,
     MessageSidFull: prepared.messageSid,
-    MediaPath: media?.path,
-    MediaType: media?.contentType,
-    MediaUrl: media?.path,
+    MessageSids: prepared.messageSids,
+    MessageSidFirst: prepared.messageSidFirst,
+    MessageSidLast: prepared.messageSidLast,
+    ...mediaPayload,
     GroupSystemPrompt: prepared.groupSystemPrompt,
     OriginatingChannel: CHANNEL_ID,
     OriginatingTo: `${CHANNEL_ID}:${prepared.toWxid}`,
@@ -455,19 +603,52 @@ export async function handleGeweInbound(params: {
   downloadQueue: GeweDownloadQueue;
   statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
 }): Promise<void> {
-  const { message, account, config, runtime, downloadQueue, statusSink } = params;
+  await handleGeweInboundBatch({
+    messages: [params.message],
+    account: params.account,
+    config: params.config,
+    runtime: params.runtime,
+    downloadQueue: params.downloadQueue,
+    statusSink: params.statusSink,
+  });
+}
+
+export async function handleGeweInboundBatch(params: {
+  messages: GeweInboundMessage[];
+  account: ResolvedGeweAccount;
+  config: CoreConfig;
+  runtime: RuntimeEnv;
+  downloadQueue: GeweDownloadQueue;
+  statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
+}): Promise<void> {
+  const { messages, account, config, runtime, downloadQueue, statusSink } = params;
+  if (messages.length === 0) {
+    return;
+  }
+
   const core = getGeweRuntime();
+  const entries = messages
+    .map((message) => normalizeInboundEntry({ message, runtime }))
+    .filter((entry): entry is NormalizedInboundEntry => Boolean(entry));
+  if (entries.length === 0) {
+    return;
+  }
 
-  const msgType = message.msgType;
-  if (![1, 3, 34, 43, 49].includes(msgType)) {
-    runtime.log?.(`gewe: skip unsupported msgType ${msgType}`);
+  const lastMessage = entries.at(-1)!.message;
+  const isGroup = lastMessage.isGroupChat;
+  const senderId = lastMessage.senderId;
+  const senderName = lastMessage.senderName;
+  const groupId = isGroup ? resolveGroupConversationId(lastMessage) : undefined;
+  const toWxid = isGroup ? groupId ?? lastMessage.fromId : senderId;
+  const rawBodyCandidate = entries
+    .map((entry) => entry.rawBody.trim())
+    .filter(Boolean)
+    .join("\n")
+    .trim();
+  if (!rawBodyCandidate) {
+    runtime.log?.("gewe: skip empty batch");
     return;
   }
-  const isGroup = message.isGroupChat;
-  const senderId = message.senderId;
-  const senderName = message.senderName;
-  const groupId = isGroup ? message.fromId : undefined;
-  const toWxid = isGroup ? message.fromId : senderId;
 
   statusSink?.({ lastInboundAt: Date.now() });
 
@@ -515,14 +696,6 @@ export async function handleGeweInbound(params: {
     senderId,
     senderName,
   }).allowed;
-  const { text } = resolveInboundText(message);
-  const isPlainText = msgType === 1;
-  const rawBodyCandidate =
-    (isPlainText ? text.trim() : "") || resolveMediaPlaceholder(msgType);
-  if (!rawBodyCandidate.trim()) {
-    runtime.log?.("gewe: skip empty message");
-    return;
-  }
   const hasControlCommand = core.channel.text.hasControlCommand(
     rawBodyCandidate,
     config as OpenClawConfig,
@@ -639,6 +812,7 @@ export async function handleGeweInbound(params: {
   const storePath = core.channel.session.resolveStorePath(config.session?.store, {
     agentId: route.agentId,
   });
+  const messageMeta = buildGeweInboundMessageMeta(entries.map((entry) => entry.message));
 
   const prepared: PreparedInbound = {
     rawBody: rawBodyCandidate,
@@ -652,8 +826,11 @@ export async function handleGeweInbound(params: {
     route,
     storePath,
     toWxid,
-    messageSid: message.newMessageId,
-    timestamp: message.timestamp,
+    messageSid: messageMeta.messageSid ?? lastMessage.newMessageId,
+    messageSids: messageMeta.messageSids,
+    messageSidFirst: messageMeta.messageSidFirst,
+    messageSidLast: messageMeta.messageSidLast,
+    timestamp: messageMeta.timestamp ?? lastMessage.timestamp,
   };
 
   core.channel.activity.record({
@@ -662,133 +839,55 @@ export async function handleGeweInbound(params: {
     direction: "inbound",
   });
 
-  const xml = message.xml;
-  const maxBytes = resolveMediaMaxBytes(account);
-  const needsDownload =
-    msgType === 3 || msgType === 34 || msgType === 43 || msgType === 49;
-
-  if (msgType === 49 && xml) {
-    const appType = extractAppMsgType(xml);
-    if (appType === 5) {
-      const linkBody = resolveLinkBody(xml);
-      prepared.rawBody = linkBody || prepared.rawBody;
-      await dispatchGeweInbound({
-        prepared,
-        account,
-        config,
-        runtime,
-        statusSink,
-      });
-      return;
-    }
-    if (appType === 74) {
-      runtime.log?.("gewe: file notification received (skip download)");
-      return;
-    }
-    if (appType !== 6) {
-      runtime.log?.(`gewe: unhandled appmsg type ${appType ?? "unknown"}`);
-      return;
-    }
-  }
-
-  if (!needsDownload || !xml) {
+  const downloadEntries = entries.filter((entry) => Boolean(entry.download));
+  if (downloadEntries.length === 0) {
     await dispatchGeweInbound({
       prepared,
       account,
       config,
       runtime,
       statusSink,
+      mediaList: [],
     });
     return;
   }
 
-  const jobKey = `${message.appId}:${message.newMessageId}`;
+  const maxBytes = resolveMediaMaxBytes(account);
+  const messageIds = entries.map((entry) => entry.message.newMessageId);
+  const jobKey = `${lastMessage.appId}:${messageIds[0]}:${messageIds.at(-1)}:${messageIds.length}`;
   const enqueued = downloadQueue.enqueue({
     key: jobKey,
     run: async () => {
-      try {
-        let fileUrl: string | null = null;
-        if (msgType === 3) {
-          try {
-            fileUrl = await downloadGeweImage({ account, xml, type: 2 });
-          } catch {
-            try {
-              fileUrl = await downloadGeweImage({ account, xml, type: 1 });
-            } catch {
-              fileUrl = await downloadGeweImage({ account, xml, type: 3 });
-            }
-          }
-        } else if (msgType === 34) {
-          fileUrl = await downloadGeweVoice({ account, xml, msgId: Number(message.messageId) });
-        } else if (msgType === 43) {
-          fileUrl = await downloadGeweVideo({ account, xml });
-        } else if (msgType === 49) {
-          fileUrl = await downloadGeweFile({ account, xml });
-        }
-
-        if (!fileUrl) {
-          await dispatchGeweInbound({
-            prepared,
-            account,
-            config,
-            runtime,
-            statusSink,
-          });
-          return;
-        }
-
-        const fetched = await core.channel.media.fetchRemoteMedia({
-          url: fileUrl,
-          maxBytes,
-          filePathHint: fileUrl,
-        });
-        let buffer = fetched.buffer;
-        let contentType = fetched.contentType;
-        let originalFilename = msgType === 49 ? extractFileName(xml) : fetched.fileName;
-
-        if (msgType === 34 && looksLikeSilkVoice({ buffer, contentType, fileName: originalFilename })) {
-          const decoded = await decodeSilkVoice({
+      const mediaList: Array<{ path: string; contentType?: string | null }> = [];
+      for (const entry of downloadEntries) {
+        try {
+          const saved = await downloadInboundMediaEntry({
+            entry,
             account,
-            buffer,
-            fileName: originalFilename,
+            maxBytes,
           });
-          if (decoded) {
-            buffer = decoded.buffer;
-            contentType = decoded.contentType;
-            originalFilename = decoded.fileName;
+          if (saved) {
+            mediaList.push(saved);
           }
+        } catch (err) {
+          runtime.error?.(
+            `gewe: media download failed for ${entry.message.newMessageId}: ${String(err)}`,
+          );
         }
-
-        const saved = await core.channel.media.saveMediaBuffer(
-          buffer,
-          contentType,
-          "inbound",
-          maxBytes,
-          originalFilename,
-        );
-
-        await dispatchGeweInbound({
-          prepared,
-          account,
-          config,
-          runtime,
-          statusSink,
-          media: { path: saved.path, contentType: saved.contentType },
-        });
-      } catch (err) {
-        runtime.error?.(`gewe: media download failed: ${String(err)}`);
-        await dispatchGeweInbound({
-          prepared,
-          account,
-          config,
-          runtime,
-          statusSink,
-        });
       }
+
+      await dispatchGeweInbound({
+        prepared,
+        account,
+        config,
+        runtime,
+        statusSink,
+        mediaList,
+      });
     },
   });
 
   if (!enqueued) {
-    runtime.log?.(`gewe: duplicate message ${jobKey} skipped`);
+    runtime.log?.(`gewe: duplicate inbound batch ${jobKey} skipped`);
   }
 }

package/src/monitor.ts

@@ -1,10 +1,11 @@
 import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
 
-import type { RuntimeEnv } from "openclaw/plugin-sdk";
+import type { OpenClawConfig, RuntimeEnv } from "openclaw/plugin-sdk";
 
 import { resolveGeweAccount } from "./accounts.js";
 import { GeweDownloadQueue } from "./download-queue.js";
-import { handleGeweInbound } from "./inbound.js";
+import { createGeweInboundDebouncer } from "./inbound-batch.js";
+import { handleGeweInboundBatch } from "./inbound.js";
 import { createGeweMediaServer, DEFAULT_MEDIA_HOST, DEFAULT_MEDIA_PATH, DEFAULT_MEDIA_PORT } from "./media-server.js";
 import { getGeweRuntime } from "./runtime.js";
 import type {
@@ -280,6 +281,22 @@ export async function monitorGeweProvider(
     minDelayMs: account.config.downloadMinDelayMs,
     maxDelayMs: account.config.downloadMaxDelayMs,
   });
+  const debouncer = createGeweInboundDebouncer({
+    cfg: cfg as OpenClawConfig,
+    accountId: account.accountId,
+    isControlCommand: (text) => core.channel.text.hasControlCommand(text, cfg as OpenClawConfig),
+    onFlush: async (messages) => {
+      await handleGeweInboundBatch({
+        messages,
+        account,
+        config: cfg,
+        runtime,
+        downloadQueue,
+        statusSink: opts.statusSink,
+      });
+    },
+    onError: (err) => runtime.error?.(`gewe inbound debounce flush failed: ${String(err)}`),
+  });
 
   const webhookServer = createGeweWebhookServer({
     port,
@@ -292,15 +309,9 @@ export async function monitorGeweProvider(
 
       const dedupeKey = `${message.appId}:${message.newMessageId}`;
       if (isDuplicate(dedupeKey)) return;
+      opts.statusSink?.({ lastInboundAt: Date.now() });
 
-      await handleGeweInbound({
-        message,
-        account,
-        config: cfg,
-        runtime,
-        downloadQueue,
-        statusSink: opts.statusSink,
-      });
+      await debouncer.enqueue(message);
     },
     onError: (err) => runtime.error?.(`gewe webhook error: ${String(err)}`),
     abortSignal: opts.abortSignal,
@@ -340,6 +351,7 @@ export async function monitorGeweProvider(
   });
 
   const stop = () => {
+    void debouncer.flushAll();
     webhookServer.stop();
     if (mediaStop) mediaStop();
     resolveRunning?.();