test(channels): align outbound delivery assertions

extensions/discord/src/channel.message-adapter.test.ts

@@ -142,17 +142,22 @@ describe("discord channel message adapter", () => {
         payload: { text: "payload" },
         accountId: "default",
       });
-      expect(hoisted.sendMessageDiscordMock).toHaveBeenLastCalledWith("channel:123456", "payload", {
-        verbose: false,
-        replyTo: undefined,
-        accountId: "default",
-        silent: undefined,
-        cfg: {},
-        textLimit: undefined,
-        maxLinesPerMessage: undefined,
-        tableMode: undefined,
-        chunkMode: undefined,
-      });
+      expect(hoisted.sendMessageDiscordMock).toHaveBeenLastCalledWith(
+        "channel:123456",
+        "payload",
+        expect.objectContaining({
+          verbose: false,
+          replyTo: undefined,
+          accountId: "default",
+          silent: undefined,
+          cfg: {},
+          textLimit: undefined,
+          maxLinesPerMessage: undefined,
+          tableMode: undefined,
+          chunkMode: undefined,
+          onDeliveryResult: expect.any(Function),
+        }),
+      );
       expect(result.receipt.platformMessageIds).toEqual(["msg-1"]);
     };
 

extensions/discord/src/outbound-adapter.interactive-order.test.ts

@@ -52,7 +52,7 @@ describe("discordOutbound shared interactive ordering", () => {
 
     expect(hoisted.sendDiscordComponentMessageMock).toHaveBeenCalledWith(
       "channel:123456",
-      {
+      expect.objectContaining({
         blocks: [
           { type: "text", text: "First" },
           {
@@ -61,8 +61,8 @@ describe("discordOutbound shared interactive ordering", () => {
           },
           { type: "text", text: "Last" },
         ],
-      },
-      {
+      }),
+      expect.objectContaining({
         accountId: undefined,
         chunkMode: undefined,
         cfg: {},
@@ -71,7 +71,7 @@ describe("discordOutbound shared interactive ordering", () => {
         silent: undefined,
         tableMode: undefined,
         textLimit: undefined,
-      },
+      }),
     );
     expect(hoisted.sendMessageDiscordMock).not.toHaveBeenCalled();
     expect(result).toEqual({

extensions/matrix/src/matrix/sdk/transport.test.ts

@@ -576,7 +576,14 @@ describe("matrix transport streaming OOM guard — real HTTP server without Cont
       // Deliberately omit Content-Length so enforceDeclaredResponseSize is a no-op.
       res.writeHead(200, { "content-type": "application/octet-stream" });
       let sent = 0;
+      let closed = false;
+      res.on("close", () => {
+        closed = true;
+      });
       const sendChunk = () => {
+        if (closed) {
+          return;
+        }
         if (sent >= TOTAL_CHUNKS) {
           res.end();
           return;
@@ -584,8 +591,14 @@ describe("matrix transport streaming OOM guard — real HTTP server without Cont
         sent++;
         chunksWritten++;
         const ok = res.write(CHUNK);
-        if (ok) { setImmediate(sendChunk); }
-        else { res.once("drain", sendChunk); }
+        const scheduleNextChunk = () => {
+          setTimeout(sendChunk, 5);
+        };
+        if (ok) {
+          scheduleNextChunk();
+        } else {
+          res.once("drain", scheduleNextChunk);
+        }
       };
       sendChunk();
     });
@@ -637,20 +650,21 @@ describe("matrix transport streaming OOM guard — real HTTP server without Cont
     const { port } = server.address() as { port: number };
 
     try {
-      const result = (await performMatrixRequest({
-        homeserver: `http://127.0.0.1:${port}`,
-        accessToken: "token",
-        method: "GET",
-        endpoint: "/_matrix/media/v3/download/example/id",
-        timeoutMs: 10_000,
-        raw: true,
-        maxBytes: 16 * 1024 * 1024,
-        ssrfPolicy: { allowPrivateNetwork: true },
-      })).buffer;
+      const result = (
+        await performMatrixRequest({
+          homeserver: `http://127.0.0.1:${port}`,
+          accessToken: "token",
+          method: "GET",
+          endpoint: "/_matrix/media/v3/download/example/id",
+          timeoutMs: 10_000,
+          raw: true,
+          maxBytes: 16 * 1024 * 1024,
+          ssrfPolicy: { allowPrivateNetwork: true },
+        })
+      ).buffer;
       expect(result).toEqual(payload);
       console.log(
-        "[matrix-bound-proof] under-cap: raw buffer returned correctly, size=" +
-          result.length,
+        "[matrix-bound-proof] under-cap: raw buffer returned correctly, size=" + result.length,
       );
     } finally {
       await new Promise<void>((resolve) => {

extensions/mattermost/src/channel.test.ts

@@ -1105,7 +1105,7 @@ describe("mattermostPlugin", () => {
         }),
       );
 
-      const options = expectSingleMattermostSend("channel:CHAN1", "Pick\n\n- Plugins");
+      const options = expectSingleMattermostSend("channel:CHAN1", "Pick\n\n- Plugins: `/codex`");
       expect(options.buttons).toBeUndefined();
     });
 

extensions/mattermost/src/mattermost/reply-delivery.test.ts

@@ -216,11 +216,11 @@ describe("deliverMattermostReplyPayload", () => {
     expect(sendMessage).toHaveBeenCalledWith(
       "channel:town-square",
       "Intro line\nReasoning: appears in content but is not a prefix",
-      {
+      expect.objectContaining({
         cfg,
         accountId: "default",
         replyToId: "root-post",
-      },
+      }),
     );
   });
 
@@ -251,19 +251,23 @@ describe("deliverMattermostReplyPayload", () => {
       });
 
       expect(sendMessage).toHaveBeenCalledTimes(1);
-      expect(sendMessage).toHaveBeenCalledWith("channel:town-square", "caption", {
-        cfg,
-        accountId: "default",
-        mediaUrl,
-        replyToId: "root-post",
-        mediaLocalRoots: expect.arrayContaining([
-          path.join(stateDir, "media"),
-          path.join(stateDir, "canvas"),
-          path.join(stateDir, "workspace"),
-          path.join(stateDir, "sandboxes"),
-          path.join(stateDir, `workspace-${agentId}`),
-        ]),
-      });
+      expect(sendMessage).toHaveBeenCalledWith(
+        "channel:town-square",
+        "caption",
+        expect.objectContaining({
+          cfg,
+          accountId: "default",
+          mediaUrl,
+          replyToId: "root-post",
+          mediaLocalRoots: expect.arrayContaining([
+            path.join(stateDir, "media"),
+            path.join(stateDir, "canvas"),
+            path.join(stateDir, "workspace"),
+            path.join(stateDir, "sandboxes"),
+            path.join(stateDir, `workspace-${agentId}`),
+          ]),
+        }),
+      );
     } finally {
       if (previousStateDir === undefined) {
         delete process.env.OPENCLAW_STATE_DIR;
@@ -294,11 +298,15 @@ describe("deliverMattermostReplyPayload", () => {
     });
 
     expect(sendMessage).toHaveBeenCalledTimes(1);
-    expect(sendMessage).toHaveBeenCalledWith("channel:town-square", "hello", {
-      cfg,
-      accountId: "default",
-      replyToId: "root-post",
-    });
+    expect(sendMessage).toHaveBeenCalledWith(
+      "channel:town-square",
+      "hello",
+      expect.objectContaining({
+        cfg,
+        accountId: "default",
+        replyToId: "root-post",
+      }),
+    );
     expect(outcome).toBe("text");
   });
 });

extensions/mattermost/src/mattermost/slash-http.send-config.test.ts

@@ -260,10 +260,10 @@ describe("slash-http cfg threading", () => {
     expect(mockState.sendMessageMattermost).toHaveBeenCalledWith(
       "channel:chan-1",
       "No models available.",
-      {
+      expect.objectContaining({
         cfg,
         accountId: "default",
-      },
+      }),
     );
   });
 

extensions/slack/src/outbound-delivery.test.ts

@@ -108,11 +108,16 @@ describe("slack outbound shared hook wiring", () => {
       replyToId: "1712000000.000001",
     });
 
-    expect(sendMessageSlackMock).toHaveBeenCalledWith("C123", "hello", {
-      cfg,
-      threadTs: "1712000000.000001",
-      accountId: "default",
-    });
+    expect(sendMessageSlackMock).toHaveBeenCalledWith(
+      "C123",
+      "hello",
+      expect.objectContaining({
+        cfg,
+        threadTs: "1712000000.000001",
+        accountId: "default",
+        onDeliveryResult: expect.any(Function),
+      }),
+    );
   });
 
   it("respects cancel from the shared hook without a second adapter pass", async () => {

extensions/whatsapp/src/auto-reply/deliver-reply.test.ts

@@ -811,14 +811,19 @@ describe("deliverWebReply", () => {
     });
 
     expect(sendWhatsApp).toHaveBeenCalledTimes(1);
-    expect(sendWhatsApp).toHaveBeenCalledWith("5511999999999@c.us", "caption", {
-      verbose: false,
-      cfg: {},
-      mediaUrl: "/tmp/voice.ogg",
-      mediaLocalRoots: undefined,
-      accountId: undefined,
-      gifPlayback: undefined,
-    });
+    expect(sendWhatsApp).toHaveBeenCalledWith(
+      "5511999999999@c.us",
+      "caption",
+      expect.objectContaining({
+        verbose: false,
+        cfg: {},
+        mediaUrl: "/tmp/voice.ogg",
+        mediaLocalRoots: undefined,
+        accountId: undefined,
+        gifPlayback: undefined,
+        onDeliveryResult: expect.any(Function),
+      }),
+    );
     expect(loadWebMedia).toHaveBeenCalledWith("/tmp/voice.ogg", {
       maxBytes: 1024 * 1024,
       localRoots: undefined,

extensions/whatsapp/src/outbound-adapter.sendpayload.test.ts

@@ -86,20 +86,32 @@ describe("whatsappOutbound sendPayload", () => {
       deps: { sendWhatsApp },
     });
 
-    expect(sendWhatsApp).toHaveBeenNthCalledWith(1, "5511999999999@c.us", "hello", {
-      verbose: false,
-      cfg: {},
-      accountId: undefined,
-      gifPlayback: undefined,
-    });
-    expect(sendWhatsApp).toHaveBeenNthCalledWith(2, "5511999999999@c.us", "caption", {
-      verbose: false,
-      cfg: {},
-      mediaUrl: "/tmp/test.png",
-      mediaLocalRoots: undefined,
-      accountId: undefined,
-      gifPlayback: undefined,
-    });
+    expect(sendWhatsApp).toHaveBeenNthCalledWith(
+      1,
+      "5511999999999@c.us",
+      "hello",
+      expect.objectContaining({
+        verbose: false,
+        cfg: {},
+        accountId: undefined,
+        gifPlayback: undefined,
+        onDeliveryResult: expect.any(Function),
+      }),
+    );
+    expect(sendWhatsApp).toHaveBeenNthCalledWith(
+      2,
+      "5511999999999@c.us",
+      "caption",
+      expect.objectContaining({
+        verbose: false,
+        cfg: {},
+        mediaUrl: "/tmp/test.png",
+        mediaLocalRoots: undefined,
+        accountId: undefined,
+        gifPlayback: undefined,
+        onDeliveryResult: expect.any(Function),
+      }),
+    );
   });
 
   it("preserves audioAsVoice from payload media sends", async () => {
@@ -113,15 +125,20 @@ describe("whatsappOutbound sendPayload", () => {
       deps: { sendWhatsApp },
     });
 
-    expect(sendWhatsApp).toHaveBeenCalledWith("5511999999999@c.us", "voice", {
-      verbose: false,
-      cfg: {},
-      mediaUrl: "/tmp/voice.ogg",
-      mediaLocalRoots: undefined,
-      audioAsVoice: true,
-      accountId: undefined,
-      gifPlayback: undefined,
-    });
+    expect(sendWhatsApp).toHaveBeenCalledWith(
+      "5511999999999@c.us",
+      "voice",
+      expect.objectContaining({
+        verbose: false,
+        cfg: {},
+        mediaUrl: "/tmp/voice.ogg",
+        mediaLocalRoots: undefined,
+        audioAsVoice: true,
+        accountId: undefined,
+        gifPlayback: undefined,
+        onDeliveryResult: expect.any(Function),
+      }),
+    );
   });
 
   it("drops blank mediaUrls before sending payload media", async () => {
@@ -139,14 +156,19 @@ describe("whatsappOutbound sendPayload", () => {
     });
 
     expect(sendWhatsApp).toHaveBeenCalledTimes(1);
-    expect(sendWhatsApp).toHaveBeenCalledWith("5511999999999@c.us", "caption", {
-      verbose: false,
-      cfg: {},
-      mediaUrl: "/tmp/voice.ogg",
-      mediaLocalRoots: undefined,
-      accountId: undefined,
-      gifPlayback: undefined,
-    });
+    expect(sendWhatsApp).toHaveBeenCalledWith(
+      "5511999999999@c.us",
+      "caption",
+      expect.objectContaining({
+        verbose: false,
+        cfg: {},
+        mediaUrl: "/tmp/voice.ogg",
+        mediaLocalRoots: undefined,
+        accountId: undefined,
+        gifPlayback: undefined,
+        onDeliveryResult: expect.any(Function),
+      }),
+    );
   });
 
   it("skips whitespace-only text payloads", async () => {

extensions/whatsapp/src/outbound-payload.contract.test.ts

@@ -70,17 +70,21 @@ describe("WhatsApp outbound payload contract", () => {
     });
 
     expect(sendWhatsApp).toHaveBeenCalledTimes(1);
-    expect(sendWhatsApp).toHaveBeenCalledWith("5511999999999@c.us", "caption", {
-      verbose: false,
-      cfg: {},
-      mediaUrl: "/tmp/voice.ogg",
-      mediaAccess: undefined,
-      mediaLocalRoots: undefined,
-      mediaReadFile: undefined,
-      accountId: undefined,
-      gifPlayback: undefined,
-      quotedMessageKey: undefined,
-    });
+    expect(sendWhatsApp).toHaveBeenCalledWith(
+      "5511999999999@c.us",
+      "caption",
+      expect.objectContaining({
+        verbose: false,
+        cfg: {},
+        mediaUrl: "/tmp/voice.ogg",
+        mediaAccess: undefined,
+        mediaLocalRoots: undefined,
+        mediaReadFile: undefined,
+        accountId: undefined,
+        gifPlayback: undefined,
+        onDeliveryResult: expect.any(Function),
+      }),
+    );
   });
 
   it("backs declared durable final capabilities with delivery proofs", async () => {

extensions/zalouser/src/channel.test.ts

@@ -108,17 +108,22 @@ describe("zalouser outbound", () => {
       accountId: "default",
     } as never);
 
-    expect(mockSendMessage).toHaveBeenCalledWith("123456", "hello world\nthis is a test", {
-      profile: "default",
-      isGroup: true,
-      textMode: "markdown",
-      textChunkMode: "newline",
-      textChunkLimit: 10,
-    });
+    expect(mockSendMessage).toHaveBeenCalledWith(
+      "123456",
+      "hello world\nthis is a test",
+      expect.objectContaining({
+        profile: "default",
+        isGroup: true,
+        textMode: "markdown",
+        textChunkMode: "newline",
+        textChunkLimit: 10,
+        onDeliveryResult: expect.any(Function),
+      }),
+    );
     expect(result).toEqual({
       channel: "zalouser",
       messageId: "mid-1",
-      ok: true,
+      receipt: undefined,
     });
   });
 
@@ -142,17 +147,22 @@ describe("zalouser outbound", () => {
       accountId: "work",
     } as never);
 
-    expect(mockSendMessage).toHaveBeenCalledWith("987654", "hello user", {
-      profile: "work-profile",
-      isGroup: false,
-      textMode: "markdown",
-      textChunkMode: "newline",
-      textChunkLimit: 10,
-    });
+    expect(mockSendMessage).toHaveBeenCalledWith(
+      "987654",
+      "hello user",
+      expect.objectContaining({
+        profile: "work-profile",
+        isGroup: false,
+        textMode: "markdown",
+        textChunkMode: "newline",
+        textChunkLimit: 10,
+        onDeliveryResult: expect.any(Function),
+      }),
+    );
     expect(result).toEqual({
       channel: "zalouser",
       messageId: "mid-1",
-      ok: true,
+      receipt: undefined,
     });
   });
 
@@ -165,13 +175,18 @@ describe("zalouser outbound", () => {
       text: "hello default",
     } as never);
 
-    expect(mockSendMessage).toHaveBeenCalledWith("111222", "hello default", {
-      profile: "default",
-      isGroup: false,
-      textMode: "markdown",
-      textChunkMode: "newline",
-      textChunkLimit: 10,
-    });
+    expect(mockSendMessage).toHaveBeenCalledWith(
+      "111222",
+      "hello default",
+      expect.objectContaining({
+        profile: "default",
+        isGroup: false,
+        textMode: "markdown",
+        textChunkMode: "newline",
+        textChunkLimit: 10,
+        onDeliveryResult: expect.any(Function),
+      }),
+    );
   });
 });