fix(dispatch): exclude isReasoning payloads from TTS synthesis

ml12580 · ml12580 · commit 49ae7ca0ce48 · 2026-06-25T09:06:59.000+08:00
When a channel opts in via supportsReasoningBlocks (Matrix), explicit isReasoning payloads flow past the generic suppression guards and can reach TTS: the per-block TTS application, sendFinalPayload final TTS, and the post-stream accumulated-block TTS-only synthetic reply. Reasoning is private thinking text delivered as its own notice (Matrix m.notice); it must never be synthesized into audio. Exclude isReasoning from the block TTS accumulator (accumulatedBlockTtsText + blockCount) and short-circuit maybeApplyTtsToReplyPayload for isReasoning payloads. The TTS skip is a no-op for channels that suppress reasoning before delivery, since such payloads never reach TTS today. Addresses ClawSweeper P2 review findings on PR #93830: - dispatch-from-config.ts:3107 (accumulated block TTS) - dispatch-from-config.ts:3279 (final TTS) Adds two regression tests covering both paths.
diff --git a/src/auto-reply/reply/dispatch-from-config.test.ts b/src/auto-reply/reply/dispatch-from-config.test.ts
@@ -7396,6 +7396,83 @@ describe("dispatchReplyFromConfig", () => {
     expect(blockReplySentTexts).toContain("The answer is 42");
   });
 
+  it("does not synthesize TTS for forwarded isReasoning final replies (opted-in channel)", async () => {
+    setNoAbort();
+    ttsMocks.state.synthesizeFinalAudio = true;
+    const dispatcher = createDispatcher();
+    const ctx = buildTestCtx({ Provider: "matrix" });
+    const replyResolver = async () =>
+      [
+        { text: "thinking...", isReasoning: true },
+        { text: "The answer is 42" },
+      ] satisfies ReplyPayload[];
+    await dispatchReplyFromConfig({
+      ctx,
+      cfg: emptyConfig,
+      dispatcher,
+      replyResolver,
+      replyOptions: { supportsReasoningBlocks: true },
+    });
+    const finalCalls = (dispatcher.sendFinalReply as ReturnType<typeof vi.fn>).mock.calls;
+    // Both payloads are still delivered (forwarded) — TTS exclusion must not
+    // suppress the reasoning notice.
+    expect(finalCalls).toHaveLength(2);
+    const reasoningFinal = finalCalls[0]?.[0] as ReplyPayload | undefined;
+    const answerFinal = finalCalls[1]?.[0] as ReplyPayload | undefined;
+    expect(reasoningFinal?.text).toBe("thinking...");
+    // The reasoning notice is NOT synthesized into audio.
+    expect(reasoningFinal?.mediaUrl).toBeUndefined();
+    expect(ttsMocks.maybeApplyTtsToPayload).not.toHaveBeenCalledWith(
+      expect.objectContaining({ payload: expect.objectContaining({ isReasoning: true }) }),
+    );
+    // The answer is still eligible for TTS synthesis.
+    expect(answerFinal?.mediaUrl).toBe("https://example.com/tts-synth.opus");
+  });
+
+  it("excludes isReasoning blocks from accumulated block TTS-only synthesis (opted-in channel)", async () => {
+    setNoAbort();
+    ttsMocks.state.synthesizeFinalAudio = true;
+    const dispatcher = createDispatcher();
+    const ctx = buildTestCtx({
+      Provider: "feishu",
+      Surface: "feishu",
+      SessionKey: "agent:main:feishu:ou_user",
+    });
+    const blockReplySentTexts: string[] = [];
+    const replyResolver = async (
+      _ctx: MsgContext,
+      opts?: GetReplyOptions,
+    ): Promise<ReplyPayload | undefined> => {
+      await opts?.onBlockReply?.({ text: "thinking...", isReasoning: true });
+      await opts?.onBlockReply?.({ text: "The answer is 42" });
+      return undefined;
+    };
+    (dispatcher.sendBlockReply as ReturnType<typeof vi.fn>).mockImplementation(
+      (payload: ReplyPayload) => {
+        if (payload.text) {
+          blockReplySentTexts.push(payload.text);
+        }
+        return true;
+      },
+    );
+    await dispatchReplyFromConfig({
+      ctx,
+      cfg: emptyConfig,
+      dispatcher,
+      replyResolver,
+      replyOptions: { supportsReasoningBlocks: true },
+    });
+    // The reasoning block is forwarded as its own notice (not suppressed).
+    expect(blockReplySentTexts).toContain("thinking...");
+    expect(blockReplySentTexts).toContain("The answer is 42");
+    // The post-stream TTS-only synthetic reply is built from the accumulated
+    // block text. Reasoning text must NOT be synthesized into audio.
+    const ttsOnlyPayload = firstFinalReplyPayload(dispatcher);
+    expect(ttsOnlyPayload?.mediaUrl).toBe("https://example.com/tts-synth.opus");
+    expect(ttsOnlyPayload?.spokenText).toBe("The answer is 42");
+    expect(ttsOnlyPayload?.spokenText).not.toContain("thinking");
+  });
+
   it("strips split TTS directives from streamed block text before delivery", async () => {
     setNoAbort();
     ttsMocks.state.synthesizeFinalAudio = true;
diff --git a/src/auto-reply/reply/dispatch-from-config.ts b/src/auto-reply/reply/dispatch-from-config.ts
@@ -345,6 +345,15 @@ async function maybeApplyTtsToReplyPayload(
   if (isReplyPayloadStatusNotice(params.payload)) {
     return params.payload;
   }
+  // Reasoning payloads are private thinking text delivered as their own
+  // notice on opted-in channels (e.g. Matrix m.notice). They must never be
+  // synthesised into audio, so skip TTS application for them on every path
+  // (final reply, per-block reply, and the post-stream TTS-only synthetic).
+  // This is a no-op for channels that suppress reasoning before delivery,
+  // since such payloads never reach TTS today.
+  if (params.payload.isReasoning === true) {
+    return params.payload;
+  }
   if (
     !shouldAttemptTtsPayload({
       cfg: params.cfg,
@@ -3180,9 +3189,14 @@ export async function dispatchReplyFromConfig(
                 }
                 // Accumulate block text for TTS generation after streaming.
                 // Exclude status notices — they are informational UI signals
-                // and must not be synthesised into the spoken reply.
+                // and must not be synthesised into the spoken reply. Exclude
+                // explicit reasoning payloads too: opted-in channels deliver
+                // them as their own notice (e.g. Matrix m.notice), so reasoning
+                // text must never be accumulated into the post-stream TTS-only
+                // synthetic reply or counted toward the TTS block gate.
                 const isStatusNotice = isReplyPayloadStatusNotice(payload);
-                if (payload.text && !isStatusNotice) {
+                const isReasoningBlock = payload.isReasoning === true;
+                if (payload.text && !isStatusNotice && !isReasoningBlock) {
                   const joinsBufferedTtsDirective =
                     cleanBlockTtsDirectiveText?.hasBufferedDirectiveText() === true;
                   if (accumulatedBlockText.length > 0) {
