fix(speech): keep TTS truncation UTF-16 safe

Alix-007 · Alix-007 · commit 015bfd9a09b8 · 2026-07-07T11:00:19.000+08:00
diff --git a/packages/speech-core/src/tts.test.ts b/packages/speech-core/src/tts.test.ts
@@ -115,6 +115,8 @@ const {
   getTtsProvider,
   maybeApplyTtsToPayload,
   resolveTtsConfig,
+  setSummarizationEnabled,
+  setTtsMaxLength,
   synthesizeSpeech,
   textToSpeechTelephony,
 } = await import("./tts.js");
@@ -174,6 +176,24 @@ function requireFirstSynthesisRequest(label: string): Record<string, unknown> {
   return requireRecord(requireFirstCallParam(synthesizeMock.mock.calls, label), label);
 }
 
+function hasLoneSurrogate(value: string): boolean {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 0xd800 && code <= 0xdbff) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 0xdc00 && next <= 0xdfff)) {
+        return true;
+      }
+      index += 1;
+      continue;
+    }
+    if (code >= 0xdc00 && code <= 0xdfff) {
+      return true;
+    }
+  }
+  return false;
+}
+
 function requireAttempt(attempts: unknown[] | undefined, index: number) {
   if (!attempts) {
     throw new Error("expected synthesis attempts");
@@ -938,6 +958,36 @@ describe("speech-core native voice-note routing", () => {
     }
   });
 
+  it("truncates long TTS text on a UTF-16 boundary", async () => {
+    const prefsName = "openclaw-speech-core-utf16-truncate-test";
+    const prefsPath = `/tmp/${prefsName}.json`;
+    const cfg = createTtsConfig(prefsName);
+    setTtsMaxLength(prefsPath, 11);
+    setSummarizationEnabled(prefsPath, false);
+    let mediaDir: string | undefined;
+    try {
+      const result = await maybeApplyTtsToPayload({
+        payload: { text: `${"a".repeat(7)}😀tail long enough for TTS` },
+        cfg,
+        channel: "telegram",
+        kind: "final",
+      });
+
+      expect(synthesizeMock).toHaveBeenCalled();
+      const request = requireFirstSynthesisRequest("utf16 truncated TTS request");
+      const spokenText = String(request.text);
+      expect(hasLoneSurrogate(spokenText)).toBe(false);
+      expect(spokenText).toBe(`${"a".repeat(7)}...`);
+      expect(result.spokenText).toBe(spokenText);
+      mediaDir = result.mediaUrl ? path.dirname(result.mediaUrl) : undefined;
+    } finally {
+      rmSync(prefsPath, { force: true });
+      if (mediaDir) {
+        rmSync(mediaDir, { recursive: true, force: true });
+      }
+    }
+  });
+
   it("skips block delivery kind in final mode (accumulated final tail synthesizes instead)", async () => {
     synthesizeMock.mockClear();
     const cfg = createTtsConfig("openclaw-speech-core-block-kind-tts-test");
diff --git a/packages/speech-core/src/tts.ts b/packages/speech-core/src/tts.ts
@@ -33,7 +33,11 @@ import {
   normalizeOptionalString,
 } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { stripMarkdown } from "openclaw/plugin-sdk/text-chunking";
-import { resolveConfigDir, resolveUserPath } from "openclaw/plugin-sdk/text-utility-runtime";
+import {
+  resolveConfigDir,
+  resolveUserPath,
+  truncateUtf16Safe,
+} from "openclaw/plugin-sdk/text-utility-runtime";
 import {
   canonicalizeSpeechProviderId,
   getSpeechProvider,
@@ -2028,7 +2032,7 @@ export async function maybeApplyTtsToPayload(params: {
       logVerbose(
         `TTS: truncating long text (${textForAudio.length} > ${maxLength}), summarization disabled.`,
       );
-      textForAudio = `${textForAudio.slice(0, maxLength - 3)}...`;
+      textForAudio = `${truncateUtf16Safe(textForAudio, maxLength - 3)}...`;
     } else {
       try {
         const summary = await summarizeText({
@@ -2044,12 +2048,12 @@ export async function maybeApplyTtsToPayload(params: {
           logVerbose(
             `TTS: summary exceeded hard limit (${textForAudio.length} > ${config.maxTextLength}); truncating.`,
           );
-          textForAudio = `${textForAudio.slice(0, config.maxTextLength - 3)}...`;
+          textForAudio = `${truncateUtf16Safe(textForAudio, config.maxTextLength - 3)}...`;
         }
       } catch (err) {
         const error = err as Error;
         logVerbose(`TTS: summarization failed, truncating instead: ${error.message}`);
-        textForAudio = `${textForAudio.slice(0, maxLength - 3)}...`;
+        textForAudio = `${truncateUtf16Safe(textForAudio, maxLength - 3)}...`;
       }
     }
   }
