fix(discord): retry outbound sends on transient network errors

codexGW · codexGW · commit f9de2ac18967 · 2026-03-13T07:04:31.000-07:00
Previously, Discord reply delivery only retried on HTTP 429/5xx status codes. Network-level failures (TypeError: fetch failed, ECONNRESET, etc.) were not retried, causing silent message loss on transient network issues. This adds network error detection to both the reply delivery retry predicate and the shared Discord retry runner, matching the pattern already used by the Telegram retry policy. Fixes #5152
diff --git a/src/discord/monitor/reply-delivery.test.ts b/src/discord/monitor/reply-delivery.test.ts
@@ -354,6 +354,77 @@ describe("deliverDiscordReply", () => {
     expect(sendMessageDiscordMock).toHaveBeenCalledTimes(2);
   });
 
+  it("retries bot send on network TypeError then succeeds", async () => {
+    sendMessageDiscordMock
+      .mockRejectedValueOnce(new TypeError("fetch failed"))
+      .mockResolvedValueOnce({ messageId: "msg-1", channelId: "channel-1" });
+
+    await deliverDiscordReply({
+      replies: [{ text: "retry me" }],
+      target: "channel:123",
+      token: "token",
+      runtime,
+      cfg,
+      textLimit: 2000,
+    });
+
+    expect(sendMessageDiscordMock).toHaveBeenCalledTimes(2);
+  });
+
+  it("retries bot send on ECONNRESET then succeeds", async () => {
+    const networkErr = Object.assign(new Error("socket hang up"), { code: "ECONNRESET" });
+    sendMessageDiscordMock
+      .mockRejectedValueOnce(networkErr)
+      .mockResolvedValueOnce({ messageId: "msg-1", channelId: "channel-1" });
+
+    await deliverDiscordReply({
+      replies: [{ text: "retry me" }],
+      target: "channel:123",
+      token: "token",
+      runtime,
+      cfg,
+      textLimit: 2000,
+    });
+
+    expect(sendMessageDiscordMock).toHaveBeenCalledTimes(2);
+  });
+
+  it("does not retry on 401 auth error", async () => {
+    const authErr = Object.assign(new Error("unauthorized"), { status: 401 });
+    sendMessageDiscordMock.mockRejectedValueOnce(authErr);
+
+    await expect(
+      deliverDiscordReply({
+        replies: [{ text: "fail" }],
+        target: "channel:123",
+        token: "token",
+        runtime,
+        cfg,
+        textLimit: 2000,
+      }),
+    ).rejects.toThrow("unauthorized");
+
+    expect(sendMessageDiscordMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not retry on 400 validation error", async () => {
+    const validationErr = Object.assign(new Error("bad request"), { status: 400 });
+    sendMessageDiscordMock.mockRejectedValueOnce(validationErr);
+
+    await expect(
+      deliverDiscordReply({
+        replies: [{ text: "fail" }],
+        target: "channel:123",
+        token: "token",
+        runtime,
+        cfg,
+        textLimit: 2000,
+      }),
+    ).rejects.toThrow("bad request");
+
+    expect(sendMessageDiscordMock).toHaveBeenCalledTimes(1);
+  });
+
   it("does not retry on 4xx client errors", async () => {
     const clientErr = Object.assign(new Error("bad request"), { status: 400 });
     sendMessageDiscordMock.mockRejectedValueOnce(clientErr);
@@ -372,6 +443,23 @@ describe("deliverDiscordReply", () => {
     expect(sendMessageDiscordMock).toHaveBeenCalledTimes(1);
   });
 
+  it("exhausts retries on persistent network failure", async () => {
+    sendMessageDiscordMock.mockRejectedValue(new TypeError("fetch failed"));
+
+    await expect(
+      deliverDiscordReply({
+        replies: [{ text: "persistent failure" }],
+        target: "channel:123",
+        token: "token",
+        runtime,
+        cfg,
+        textLimit: 2000,
+      }),
+    ).rejects.toThrow("fetch failed");
+
+    expect(sendMessageDiscordMock).toHaveBeenCalledTimes(3);
+  });
+
   it("throws after exhausting retry attempts", async () => {
     const rateLimitErr = Object.assign(new Error("rate limited"), { status: 429 });
     sendMessageDiscordMock.mockRejectedValue(rateLimitErr);
diff --git a/src/discord/monitor/reply-delivery.ts b/src/discord/monitor/reply-delivery.ts
@@ -4,7 +4,11 @@ import type { ChunkMode } from "../../auto-reply/chunk.js";
 import type { ReplyPayload } from "../../auto-reply/types.js";
 import type { OpenClawConfig } from "../../config/config.js";
 import type { MarkdownTableMode, ReplyToMode } from "../../config/types.base.js";
-import { createDiscordRetryRunner, type RetryRunner } from "../../infra/retry-policy.js";
+import {
+  createDiscordRetryRunner,
+  isRetryableDiscordNetworkError,
+  type RetryRunner,
+} from "../../infra/retry-policy.js";
 import { resolveRetryConfig, retryAsync, type RetryConfig } from "../../infra/retry.js";
 import { convertMarkdownTables } from "../../markdown/tables.js";
 import type { RuntimeEnv } from "../../runtime.js";
@@ -37,6 +41,9 @@ const DISCORD_DELIVERY_RETRY_DEFAULTS: ResolvedRetryConfig = {
 };
 
 function isRetryableDiscordError(err: unknown): boolean {
+  if (isRetryableDiscordNetworkError(err)) {
+    return true;
+  }
   const status = (err as { status?: number }).status ?? (err as { statusCode?: number }).statusCode;
   return status === 429 || (status !== undefined && status >= 500);
 }
diff --git a/src/infra/retry-policy.test.ts b/src/infra/retry-policy.test.ts
@@ -1,5 +1,17 @@
 import { describe, expect, it, vi } from "vitest";
-import { createTelegramRetryRunner } from "./retry-policy.js";
+import { createDiscordRetryRunner, createTelegramRetryRunner } from "./retry-policy.js";
+
+describe("createDiscordRetryRunner", () => {
+  it("retries network errors", async () => {
+    const fn = vi.fn().mockRejectedValueOnce(new TypeError("fetch failed")).mockResolvedValue("ok");
+    const runner = createDiscordRetryRunner({
+      retry: { attempts: 2, minDelayMs: 0, maxDelayMs: 0, jitter: 0 },
+    });
+
+    await expect(runner(fn, "discord send")).resolves.toBe("ok");
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+});
 
 describe("createTelegramRetryRunner", () => {
   describe("strictShouldRetry", () => {
diff --git a/src/infra/retry-policy.ts b/src/infra/retry-policy.ts
@@ -20,6 +20,13 @@ export const TELEGRAM_RETRY_DEFAULTS = {
 };
 
 const TELEGRAM_RETRY_RE = /429|timeout|connect|reset|closed|unavailable|temporarily/i;
+const DISCORD_NETWORK_ERROR_RE = /fetch failed|network/i;
+const DISCORD_RETRYABLE_ERROR_CODES = new Set([
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ETIMEDOUT",
+  "UND_ERR_CONNECT_TIMEOUT",
+]);
 const log = createSubsystemLogger("retry-policy");
 
 function resolveTelegramShouldRetry(params: {
@@ -58,6 +65,16 @@ function getTelegramRetryAfterMs(err: unknown): number | undefined {
   return typeof candidate === "number" && Number.isFinite(candidate) ? candidate * 1000 : undefined;
 }
 
+export function isRetryableDiscordNetworkError(err: unknown): boolean {
+  if (!(err instanceof Error)) {
+    return false;
+  }
+  if (typeof (err as { code?: unknown }).code === "string") {
+    return DISCORD_RETRYABLE_ERROR_CODES.has((err as { code: string }).code);
+  }
+  return err instanceof TypeError && DISCORD_NETWORK_ERROR_RE.test(err.message);
+}
+
 export function createDiscordRetryRunner(params: {
   retry?: RetryConfig;
   configRetry?: RetryConfig;
@@ -71,7 +88,7 @@ export function createDiscordRetryRunner(params: {
     retryAsync(fn, {
       ...retryConfig,
       label,
-      shouldRetry: (err) => err instanceof RateLimitError,
+      shouldRetry: (err) => err instanceof RateLimitError || isRetryableDiscordNetworkError(err),
       retryAfterMs: (err) => (err instanceof RateLimitError ? err.retryAfter * 1000 : undefined),
       onRetry: params.verbose
         ? (info) => {
