@openclaw/discord 2026.3.13 → 2026.5.2-beta.1

package/src/voice/tts.ts

@@ -0,0 +1,125 @@
+import {
+  getTtsProvider,
+  resolveAgentDir,
+  resolveTtsConfig,
+  resolveTtsPrefsPath,
+  type ResolvedTtsConfig,
+} from "openclaw/plugin-sdk/agent-runtime";
+import type { OpenClawConfig, TtsConfig } from "openclaw/plugin-sdk/config-types";
+import { parseTtsDirectives } from "openclaw/plugin-sdk/speech";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+import { getDiscordRuntime } from "../runtime.js";
+import { sanitizeVoiceReplyTextForSpeech } from "./sanitize.js";
+
+type VoiceReplyAudioResult =
+  | {
+      status: "ok";
+      audioPath: string;
+      speakText: string;
+    }
+  | {
+      status: "empty";
+    }
+  | {
+      status: "failed";
+      error?: string;
+    };
+
+function mergeTtsConfig(base: TtsConfig, override?: TtsConfig): TtsConfig {
+  if (!override) {
+    return base;
+  }
+  const baseProviders = base.providers ?? {};
+  const overrideProviders = override.providers ?? {};
+  const mergedProviders = Object.fromEntries(
+    [...new Set([...Object.keys(baseProviders), ...Object.keys(overrideProviders)])].map(
+      (providerId) => {
+        const baseProvider = baseProviders[providerId] ?? {};
+        const overrideProvider = overrideProviders[providerId] ?? {};
+        return [
+          providerId,
+          {
+            ...baseProvider,
+            ...overrideProvider,
+          },
+        ];
+      },
+    ),
+  );
+  return {
+    ...base,
+    ...override,
+    modelOverrides: {
+      ...base.modelOverrides,
+      ...override.modelOverrides,
+    },
+    ...(Object.keys(mergedProviders).length === 0 ? {} : { providers: mergedProviders }),
+  };
+}
+
+function resolveVoiceTtsConfig(params: { cfg: OpenClawConfig; override?: TtsConfig }): {
+  cfg: OpenClawConfig;
+  resolved: ResolvedTtsConfig;
+} {
+  if (!params.override) {
+    return { cfg: params.cfg, resolved: resolveTtsConfig(params.cfg) };
+  }
+  const base = params.cfg.messages?.tts ?? {};
+  const merged = mergeTtsConfig(base, params.override);
+  const messages = params.cfg.messages ?? {};
+  const cfg = {
+    ...params.cfg,
+    messages: {
+      ...messages,
+      tts: merged,
+    },
+  };
+  return { cfg, resolved: resolveTtsConfig(cfg) };
+}
+
+export async function transcribeVoiceAudio(params: {
+  cfg: OpenClawConfig;
+  agentId: string;
+  filePath: string;
+}): Promise<string | undefined> {
+  const result = await getDiscordRuntime().mediaUnderstanding.transcribeAudioFile({
+    filePath: params.filePath,
+    cfg: params.cfg,
+    agentDir: resolveAgentDir(params.cfg, params.agentId),
+    mime: "audio/wav",
+  });
+  return normalizeOptionalString(result.text);
+}
+
+export async function synthesizeVoiceReplyAudio(params: {
+  cfg: OpenClawConfig;
+  override?: TtsConfig;
+  replyText: string;
+  speakerLabel: string;
+}): Promise<VoiceReplyAudioResult> {
+  const { cfg: ttsCfg, resolved: ttsConfig } = resolveVoiceTtsConfig({
+    cfg: params.cfg,
+    override: params.override,
+  });
+  const directive = parseTtsDirectives(params.replyText, ttsConfig.modelOverrides, {
+    cfg: ttsCfg,
+    providerConfigs: ttsConfig.providerConfigs,
+    preferredProviderId: getTtsProvider(ttsConfig, resolveTtsPrefsPath(ttsConfig)),
+  });
+  const rawSpeakText = directive.overrides.ttsText ?? directive.cleanedText.trim();
+  const speakText = sanitizeVoiceReplyTextForSpeech(rawSpeakText, params.speakerLabel);
+  if (!speakText) {
+    return { status: "empty" };
+  }
+
+  const result = await getDiscordRuntime().tts.textToSpeech({
+    text: speakText,
+    cfg: ttsCfg,
+    channel: "discord",
+    overrides: directive.overrides,
+  });
+  if (!result.success || !result.audioPath) {
+    return { status: "failed", error: result.error ?? "unknown error" };
+  }
+  return { status: "ok", audioPath: result.audioPath, speakText };
+}

package/src/voice-message.test.ts

@@ -0,0 +1,234 @@
+import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import type { RequestClient } from "./internal/discord.js";
+import type { VoiceMessageMetadata } from "./voice-message.js";
+
+const runFfprobeMock = vi.hoisted(() => vi.fn<(...args: unknown[]) => Promise<string>>());
+const runFfmpegMock = vi.hoisted(() => vi.fn<(...args: unknown[]) => Promise<void>>());
+
+vi.mock("openclaw/plugin-sdk/temp-path", async () => {
+  return {
+    resolvePreferredOpenClawTmpDir: () => "/tmp",
+  };
+});
+
+vi.mock("openclaw/plugin-sdk/media-runtime", async () => {
+  return {
+    runFfprobe: runFfprobeMock,
+    runFfmpeg: runFfmpegMock,
+    parseFfprobeCodecAndSampleRate: (stdout: string) => {
+      const [codec, sampleRate] = stdout.trim().split(",");
+      return {
+        codec,
+        sampleRateHz: Number(sampleRate),
+      };
+    },
+    MEDIA_FFMPEG_MAX_AUDIO_DURATION_SECS: 1200,
+    unlinkIfExists: vi.fn(async () => {}),
+  };
+});
+
+vi.mock("openclaw/plugin-sdk/ssrf-runtime", async () => {
+  return {
+    fetchWithSsrFGuard: async (params: { url: string; init?: RequestInit }) => ({
+      response: await globalThis.fetch(params.url, params.init),
+      release: async () => {},
+    }),
+  };
+});
+
+let ensureOggOpus: typeof import("./voice-message.js").ensureOggOpus;
+let sendDiscordVoiceMessage: typeof import("./voice-message.js").sendDiscordVoiceMessage;
+
+describe("ensureOggOpus", () => {
+  beforeAll(async () => {
+    ({ ensureOggOpus, sendDiscordVoiceMessage } = await import("./voice-message.js"));
+  });
+
+  beforeEach(() => {
+    runFfprobeMock.mockReset();
+    runFfmpegMock.mockReset();
+  });
+  it("rejects URL/protocol input paths", async () => {
+    await expect(ensureOggOpus("https://example.com/audio.ogg")).rejects.toThrow(
+      /local file path/i,
+    );
+    expect(runFfprobeMock).not.toHaveBeenCalled();
+    expect(runFfmpegMock).not.toHaveBeenCalled();
+  });
+
+  it("keeps .ogg only when codec is opus and sample rate is 48kHz", async () => {
+    runFfprobeMock.mockResolvedValueOnce("opus,48000\n");
+
+    const result = await ensureOggOpus("/tmp/input.ogg");
+
+    expect(result).toEqual({ path: "/tmp/input.ogg", cleanup: false });
+    expect(runFfprobeMock).toHaveBeenCalledWith(
+      expect.arrayContaining(["-show_entries", "stream=codec_name,sample_rate", "/tmp/input.ogg"]),
+    );
+    expect(runFfmpegMock).not.toHaveBeenCalled();
+  });
+
+  it("re-encodes .ogg opus when sample rate is not 48kHz", async () => {
+    runFfprobeMock.mockResolvedValueOnce("opus,24000\n");
+    runFfmpegMock.mockResolvedValueOnce();
+
+    const result = await ensureOggOpus("/tmp/input.ogg");
+
+    expect(result.cleanup).toBe(true);
+    expect(result.path).toMatch(/^\/tmp\/voice-.*\.ogg$/);
+    expect(runFfmpegMock).toHaveBeenCalledWith(
+      expect.arrayContaining(["-t", "1200", "-ar", "48000", "/tmp/input.ogg", result.path]),
+    );
+  });
+
+  it("re-encodes non-ogg input with bounded ffmpeg execution", async () => {
+    runFfmpegMock.mockResolvedValueOnce();
+
+    const result = await ensureOggOpus("/tmp/input.mp3");
+
+    expect(result.cleanup).toBe(true);
+    expect(runFfprobeMock).not.toHaveBeenCalled();
+    expect(runFfmpegMock).toHaveBeenCalledWith(
+      expect.arrayContaining(["-vn", "-sn", "-dn", "/tmp/input.mp3", result.path]),
+    );
+  });
+});
+
+describe("sendDiscordVoiceMessage", () => {
+  const metadata: VoiceMessageMetadata = {
+    durationSecs: 1,
+    waveform: "waveform",
+  };
+
+  beforeAll(async () => {
+    ({ sendDiscordVoiceMessage } = await import("./voice-message.js"));
+  });
+
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  function createRest(post = vi.fn(async () => ({ id: "msg-1", channel_id: "channel-1" }))) {
+    return {
+      options: { baseUrl: "https://discord.test/api/v10" },
+      post,
+    } as unknown as RequestClient;
+  }
+
+  async function retryRateLimits<T>(fn: () => Promise<T>): Promise<T> {
+    let lastError: unknown;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastError = err;
+        if (!(err instanceof Error) || err.name !== "RateLimitError") {
+          throw err;
+        }
+      }
+    }
+    throw lastError;
+  }
+
+  it("requests a fresh upload URL when the CDN upload is rate limited", async () => {
+    const post = vi.fn(async () => ({ id: "msg-1", channel_id: "channel-1" }));
+    const rest = createRest(post);
+    let uploadUrlRequests = 0;
+    const fetchMock = vi.spyOn(globalThis, "fetch").mockImplementation(async (input, init) => {
+      const url = input instanceof Request ? input.url : String(input);
+      const method = input instanceof Request ? input.method : (init?.method ?? "GET");
+      if (method === "POST" && url.endsWith("/channels/channel-1/attachments")) {
+        uploadUrlRequests += 1;
+        return new Response(
+          JSON.stringify({
+            attachments: [
+              {
+                id: 0,
+                upload_url: `https://cdn.test/upload-${uploadUrlRequests}`,
+                upload_filename: `uploaded-${uploadUrlRequests}.ogg`,
+              },
+            ],
+          }),
+          { status: 200 },
+        );
+      }
+      if (method === "PUT" && url === "https://cdn.test/upload-1") {
+        return new Response(
+          JSON.stringify({ message: "Slow down", retry_after: 0, global: false }),
+          { status: 429 },
+        );
+      }
+      if (method === "PUT" && url === "https://cdn.test/upload-2") {
+        return new Response(null, { status: 200 });
+      }
+      throw new Error(`unexpected fetch ${method} ${url}`);
+    });
+
+    await expect(
+      sendDiscordVoiceMessage(
+        rest,
+        "channel-1",
+        Buffer.from("ogg"),
+        metadata,
+        undefined,
+        retryRateLimits,
+        false,
+        "bot-token",
+      ),
+    ).resolves.toEqual({ id: "msg-1", channel_id: "channel-1" });
+
+    expect(uploadUrlRequests).toBe(2);
+    expect(fetchMock).toHaveBeenCalledTimes(4);
+    expect(post).toHaveBeenCalledWith("/channels/channel-1/messages", {
+      body: expect.objectContaining({
+        attachments: [
+          expect.objectContaining({
+            uploaded_filename: "uploaded-2.ogg",
+          }),
+        ],
+      }),
+    });
+  });
+
+  it("throws typed CDN upload failures", async () => {
+    const rest = createRest();
+    vi.spyOn(globalThis, "fetch").mockImplementation(async (input, init) => {
+      const url = input instanceof Request ? input.url : String(input);
+      const method = input instanceof Request ? input.method : (init?.method ?? "GET");
+      if (method === "POST" && url.endsWith("/channels/channel-1/attachments")) {
+        return new Response(
+          JSON.stringify({
+            attachments: [
+              {
+                id: 0,
+                upload_url: "https://cdn.test/upload",
+                upload_filename: "uploaded.ogg",
+              },
+            ],
+          }),
+          { status: 200 },
+        );
+      }
+      if (method === "PUT" && url === "https://cdn.test/upload") {
+        return new Response("cdn unavailable", { status: 503 });
+      }
+      throw new Error(`unexpected fetch ${method} ${url}`);
+    });
+
+    await expect(
+      sendDiscordVoiceMessage(
+        rest,
+        "channel-1",
+        Buffer.from("ogg"),
+        metadata,
+        undefined,
+        async (fn) => await fn(),
+        false,
+        "bot-token",
+      ),
+    ).rejects.toMatchObject({
+      name: "DiscordError",
+      status: 503,
+    });
+  });
+});