fix(telegram): suppress internal formatting artefacts from leaking into user messages (#88128)

chengzhichao-xydt · chengzhichao-xydt · commit be13928b43ba · 2026-05-30T10:45:59.000+08:00
diff --git a/src/auto-reply/reply/normalize-reply.ts b/src/auto-reply/reply/normalize-reply.ts
@@ -5,6 +5,7 @@ import { stripHeartbeatToken } from "../heartbeat.js";
 import { copyReplyPayloadMetadata } from "../reply-payload.js";
 import {
   HEARTBEAT_TOKEN,
+  isInternalFormattingArtifact,
   isSilentReplyPayloadText,
   isSilentReplyText,
   SILENT_REPLY_TOKEN,
@@ -18,7 +19,7 @@ import {
   type ResponsePrefixContext,
 } from "./response-prefix-template.js";
 
-export type NormalizeReplySkipReason = "empty" | "silent" | "heartbeat";
+export type NormalizeReplySkipReason = "empty" | "silent" | "heartbeat" | "internalArtifact";
 
 export type NormalizeReplyOptions = {
   responsePrefix?: string;
@@ -96,6 +97,14 @@ export function normalizeReplyPayload(
     text = stripped.text;
   }
 
+  // Suppress internal/runtime formatting artefacts (e.g. <channel|>, set-thought,
+  // ─── separators) that LLM providers emit during streaming but must never
+  // reach user-facing messaging channels.  See issue #88128.
+  if (text && isInternalFormattingArtifact(text) && !hasContent("")) {
+    opts.onSkip?.("internalArtifact");
+    return null;
+  }
+
   if (text) {
     text = sanitizeUserFacingText(text, { errorContext: Boolean(payload.isError) });
   }
diff --git a/src/auto-reply/reply/reply-utils.test.ts b/src/auto-reply/reply/reply-utils.test.ts
@@ -149,7 +149,7 @@ describe("normalizeReplyPayload", () => {
     expect(reply.channelData).toEqual(payload.channelData);
   });
 
-  it("records skip reasons for silent/empty payloads", () => {
+  it("records skip reasons for silent/empty/internal-artifact payloads", () => {
     const cases = [
       { name: "silent", payload: { text: SILENT_REPLY_TOKEN }, reason: "silent" },
       {
@@ -158,6 +158,21 @@ describe("normalizeReplyPayload", () => {
         reason: "silent",
       },
       { name: "empty", payload: { text: "   " }, reason: "empty" },
+      {
+        name: "internalArtifact <channel|>",
+        payload: { text: "<channel|>" },
+        reason: "internalArtifact",
+      },
+      {
+        name: "internalArtifact set-thought",
+        payload: { text: "set-thought <channel|>" },
+        reason: "internalArtifact",
+      },
+      {
+        name: "internalArtifact separator",
+        payload: { text: "───" },
+        reason: "internalArtifact",
+      },
     ] as const;
     for (const testCase of cases) {
       const reasons: string[] = [];
diff --git a/src/auto-reply/tokens.test.ts b/src/auto-reply/tokens.test.ts
@@ -1,5 +1,6 @@
 import { describe, it, expect } from "vitest";
 import {
+  isInternalFormattingArtifact,
   isSilentReplyPrefixText,
   isSilentReplyPayloadText,
   isSilentReplyText,
@@ -8,6 +9,70 @@ import {
   stripSilentToken,
 } from "./tokens.js";
 
+describe("isInternalFormattingArtifact", () => {
+  it("matches <channel|> markers (#88128)", () => {
+    expect(isInternalFormattingArtifact("<channel|>")).toBe(true);
+    expect(isInternalFormattingArtifact("  <channel|>  ")).toBe(true);
+    expect(isInternalFormattingArtifact("\n<channel|>\n")).toBe(true);
+  });
+
+  it("matches set-thought directives with channel markers (#88128)", () => {
+    expect(isInternalFormattingArtifact("set-thought <channel|>")).toBe(true);
+    expect(isInternalFormattingArtifact("  set-thought <channel|>  ")).toBe(true);
+  });
+
+  it("matches em-dash / horizontal-rule separators (#88128)", () => {
+    expect(isInternalFormattingArtifact("───")).toBe(true);
+    expect(isInternalFormattingArtifact("---")).toBe(true);
+    expect(isInternalFormattingArtifact("___")).toBe(true);
+    expect(isInternalFormattingArtifact("***")).toBe(true);
+    expect(isInternalFormattingArtifact("****")).toBe(true);
+    expect(isInternalFormattingArtifact("  ───  ")).toBe(true);
+  });
+
+  it("matches lone XML-like tags", () => {
+    expect(isInternalFormattingArtifact("<tag>")).toBe(true);
+    expect(isInternalFormattingArtifact("</tag>")).toBe(true);
+    expect(isInternalFormattingArtifact("<br/>")).toBe(true);
+  });
+
+  it("matches <word|value> channel-style markup", () => {
+    expect(isInternalFormattingArtifact("<channel|answer>")).toBe(true);
+    expect(isInternalFormattingArtifact("<lane|reasoning>")).toBe(true);
+  });
+
+  it("returns false for undefined/empty", () => {
+    expect(isInternalFormattingArtifact(undefined)).toBe(false);
+    expect(isInternalFormattingArtifact("")).toBe(false);
+  });
+
+  it("returns false for normal user-facing text", () => {
+    expect(isInternalFormattingArtifact("Hello! How can I help?")).toBe(false);
+    expect(isInternalFormattingArtifact("The answer is 42.")).toBe(false);
+    expect(isInternalFormattingArtifact("Here's your code:")).toBe(false);
+  });
+
+  it("returns false for text that merely contains an artifact pattern", () => {
+    // Real answer text that happens to include a dash separator or tag-like content
+    // must not be suppressed.
+    expect(
+      isInternalFormattingArtifact(
+        "Here are the options:\n───\n1. Option A\n2. Option B",
+      ),
+    ).toBe(false);
+    expect(isInternalFormattingArtifact("See <https://example.com> for details.")).toBe(false);
+    expect(
+      isInternalFormattingArtifact("Use <channel|> syntax in your config."),
+    ).toBe(false);
+  });
+
+  it("returns false for code blocks and markdown with substance", () => {
+    expect(isInternalFormattingArtifact("```js\nconsole.log('hi')\n```")).toBe(false);
+    expect(isInternalFormattingArtifact("**bold** and *italic* text")).toBe(false);
+    expect(isInternalFormattingArtifact("# Heading")).toBe(false);
+  });
+});
+
 describe("isSilentReplyText", () => {
   it("returns true for exact token", () => {
     expect(isSilentReplyText("NO_REPLY")).toBe(true);
diff --git a/src/auto-reply/tokens.ts b/src/auto-reply/tokens.ts
@@ -3,6 +3,33 @@ import { escapeRegExp } from "../shared/regexp.js";
 export const HEARTBEAT_TOKEN = "HEARTBEAT_OK";
 export const SILENT_REPLY_TOKEN = "NO_REPLY";
 
+/**
+ * Detects text that consists solely of internal/runtime formatting artefacts
+ * produced by LLM providers (e.g. Codex) during streaming responses.
+ *
+ * These are NOT meaningful user-facing output and must never be sent to
+ * messaging channels as visible messages.
+ *
+ * Matched patterns:
+ * - `<channel|>`, `<word|>`, `<word|value>` — incomplete/empty angle-bracket
+ *   markup used by providers for internal channel/routing markers.
+ * - `set-thought <...>` — reasoning directive prefixes emitted by Codex-style
+ *   providers to signal thought block transitions.
+ * - `───`, `---`, `___`, `***`, `****` — markdown horizontal-rule separators
+ *   when they are the only non-whitespace content.
+ * - `<tag>` / `</tag>` — lone unclosed or empty XML-like tags that are not
+ *   valid user-facing content.
+ */
+const INTERNAL_ARTEFACT_RE =
+  /^\s*(?:(?:set-thought\s+)?<[\w]*\|[^>]*>|───+|-{3,}|_{3,}|\*{3,4}|<[\w]+\/?>|<\/[\w]+>)\s*$/;
+
+export function isInternalFormattingArtifact(text: string | undefined): boolean {
+  if (!text) {
+    return false;
+  }
+  return INTERNAL_ARTEFACT_RE.test(text);
+}
+
 const silentExactRegexByToken = new Map<string, RegExp>();
 const silentTrailingRegexByToken = new Map<string, RegExp>();
 const silentLeadingAttachedRegexByToken = new Map<string, RegExp>();
